java的多线程学习，第二记
多线程带来便利的同时，也会带来麻烦
1，操作同一个共享资源的时候，会带来很多意想不到的麻烦。
就像卖票一样，如果不考虑多线程的环境，那肯定是没有问题的。
package secondSteps; /** * 卖票 * @author liugang * @create 2018/12/6 22:43 **/ public class SellTicket implements Runnable { private Integer ticketCount = 100; @Override public void run() { try { while (ticketCount>0){ sellTicket(); Thread.sleep(1000); } } catch (InterruptedException e) { e.printStackTrace(); } } private void sellTicket() { if (ticketCount>0){ ticketCount--; System.out.println("线程的名称："+Thread.currentThread().getName()+"卖票 还剩"+ticketCount+"张"); }else{ System.out.println("票卖完了"); } } //如果不考虑多线程的环境，肯定不会出问题 }
public static void main(String[] args) { SellTicket ticket = new SellTicket(); Thread t1 = new Thread(ticket,"窗口1"); t1.start(); }
运行的状况：票是一张一张的少的。
现在开四个线程卖票
public static void main(String[] args) { SellTicket ticket = new SellTicket(); Thread t1 = new Thread(ticket,"窗口1"); Thread t2 = new Thread(ticket,"窗口1"); Thread t3 = new Thread(ticket,"窗口1"); Thread t4 = new Thread(ticket,"窗口1"); t1.start(); t2.start(); t3.start(); t4.start(); }
出现这种情况，是cpu高速切换，线程1，还没有执行完，在条件判断的时候，就切换到其他的线程。
多线程解决一个共享资源的占用问题是个头疼的问题
java提供了一定的解决办法。
操作共享资源的时候，不要竞争，一个一个来。比如，春节的时候在火车上厕所，一个人进去了把门锁了，方便之后开门，出来了。
给代码加个锁，就可以搞定这个问题。java提供了关键字synchronized，这个关键字代码块是要上锁的。那上什么锁呢，万物皆可superme
private Object obj = new Object();
private void sellTicket() { synchronized (obj){ if (ticketCount>0){ ticketCount--; System.out.println("线程的名称："+Thread.currentThread().getName()+"卖票 还剩"+ticketCount+"张"); }else{ System.out.println("票卖完了"); } } }
对象是有一个标志位的，当前锁定这个标志位，另外一个线程进来了，发现标志位没改变，就动不了。
synchronized (this)//同步代码块， 锁 任何一个对象
锁自己，刚不刚，强不强，也一样的，万物皆可superme
还有可以把方法同步一样，把方法加个synchronized也一样，用哪种方法，就看自己的需求了。
代码块的好处：同步代码弄成最小的范围，提高效率。
同步方法就是 this，就是把当前对象锁了
静态方法锁，顾名思义，静态的方法锁，加个static
package secondSteps; /** * 卖票 * @author liugang * @create 2018/12/6 22:43 **/ public class SellTicket implements Runnable { private static Integer ticketCount = 100; private Object obj = new Object(); @Override public void run() { try { while (ticketCount>0){ sellTicket(); Thread.sleep(1000); } } catch (InterruptedException e) { e.printStackTrace(); } } private synchronized static void sellTicket() { //同步代码块 锁 任何一个对象 synchronized (SellTicket.class) { if (ticketCount > 0) { ticketCount--; System.out.println("线程的名称：" + Thread.currentThread().getName() + "卖票 还剩" + ticketCount + "张"); } else { System.out.println("票卖完了"); } } } //如果不考虑多线程的环境，肯定不会出问题 }
用static锁的是整个类，这样你new 出来的对象是没关系的，火车上4个人排队上一个厕所。
多个线程要同一个锁才可以。
注意：
1，同步代码块，他可以用任何一个对象作为锁
2，静态方法锁，锁的是整个类，所有对象过来都会阻塞，static是类级别，并不是某个对象。
3，synchronized方法，是锁的对象，这样是不行的。各所各的，是不一样的，是没有意思的。
线程的等待，线程的唤醒：
1，wait ----->导致获得这个锁的线程，阻塞等待，知道他被唤醒为止
2，notify ----->唤醒在等待这个锁的其他线程之一
3，notifyall ------->唤醒所有在等待的这个线程
package threeSteps; /** * 以这个类作为锁，让其他的类去等待，去唤醒 * @author liugang * @create 2018/12/6 23:30 **/ public class Message { private String msg; public Message(String msg) { this.msg = msg; } public Message() { } public String getMsg() { return msg; } public void setMsg(String msg) { this.msg = msg; } }
package threeSteps; /** * @author liugang * @create 2018/12/6 23:32 **/ public class Waiter implements Runnable{ private Message msg; public Waiter(Message msg) { this.msg = msg; } @Override public void run() { String name = Thread.currentThread().getName(); //当前线程，执行到了msg.wait()就会导致，持有这个锁的线程进行等待，一直到他被唤醒为止 synchronized (msg){ try { System.out.println(name+"等待"); msg.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } }
public static void main(String[] args) { Message msg = new Message("锁"); //同一个对象，同一个锁才行 Waiter waiter = new Waiter(msg); new Thread(waiter,"waiter").start(); Waiter waiter1 = new Waiter(msg); new Thread(waiter1,"waiter1").start(); Notifier notifier = new Notifier(msg); new Thread(notifier,"waiter").start(); }
运行结果如下：
这是因为我把notify改成notifyAll，唤醒所有了
package threeSteps; /** * 进行唤醒 * @author liugang * @create 2018/12/6 23:38 **/ public class Notifier implements Runnable{ private Message msg; public Notifier(Message msg) { this.msg = msg; } @Override public void run() { String name = Thread.currentThread().getName(); synchronized (msg){ msg.setMsg("唤醒线程工作"); // msg.notify(); msg.notifyAll(); } } }
wait运行到msg.wait()就卡死了，就一直等这了，就像我的联想笔记本动不动就卡死了，
好在有notify唤醒他，而我的笔记本就只能重启由我自己来唤醒他啦。
notify只能唤醒一个哟，另外一个只能一直卡死在那了。
notifyAll就唤醒所有，就像毛主席，是的
