线程的通讯
线程间通信其实就是多个线程在操作同一个资源,但操作动作不同
生产者消费者
如果有多个生产者和消费者,一定要使用while循环判断标记,然后在使用notifyAll唤醒,否者容易只用notify容易出现只唤醒本方线程情况,导致程序中的所有线程都在等待。
例如:有一个数据存储空间,划分为两个部分,一部分存储人的姓名,一部分存储性别,我们开启一个线程,不停地想其中存储姓名和性别(生产者),开启另一个线程从数据存储空间中取出数据(消费者)。
由于是多线程的,就需要考虑,假如生产者刚向数据存储空间中添加了一个人名,还没有来得及添加性别,cpu就切换到了消费者的线程,消费者就会将这个人的姓名和上一个人的性别进行了输出。
还有一种情况是生产者生产了若干次数据,消费者才开始取数据,或者消费者取出数据后,没有等到消费者放入新的数据,消费者又重复的取出自己已经去过的数据。
public class Demo10 { public static void main(String[] args) { Person p = new Person(); Producer pro = new Producer(p); Consumer con = new Consumer(p); Thread t1 = new Thread(pro, "生产者"); Thread t2 = new Thread(con, "消费者"); t1.start(); t2.start(); } } // 使用Person作为数据存储空间 class Person { String name; String gender; } // 生产者 class Producer implements Runnable { Person p; public Producer() { } public Producer(Person p) { this.p = p; } @Override public void run() { int i = 0; while (true) { if (i % 2 == 0) { p.name = "jack"; p.gender = "man"; } else { p.name = "小丽"; p.gender = "女"; } i++; } } } // 消费者 class Consumer implements Runnable { Person p; public Consumer() { } public Consumer(Person p) { this.p = p; } @Override public void run() { while (true) { System.out.println("name:" + p.name + "---gnder:" + p.gender); } } }
在上述代码中,Producer和Consumer 类的内部都维护了一个Person类型的p成员变量,通过构造函数进行赋值,在man方法中创建了一个Person对象,将其同时传递给Producer和Consumer对象,所以Producer和Consumer访问的是同一个Person对象。并启动了两个线程。
输出:
显然屏幕输出了小丽 man 这样的结果是出现了线程安全问题。所以需要使用synchronized来解决该问题。
public class Demo10 { public static void main(String[] args) { Person p = new Person(); Producer pro = new Producer(p); Consumer con = new Consumer(p); Thread t1 = new Thread(pro, "生产者"); Thread t2 = new Thread(con, "消费者"); t1.start(); t2.start(); } } // 使用Person作为数据存储空间 class Person { String name; String gender; } // 生产者 class Producer implements Runnable { Person p; public Producer() { } public Producer(Person p) { this.p = p; } @Override public void run() { int i = 0; while (true) { synchronized (p) { if (i % 2 == 0) { p.name = "jack"; p.gender = "man"; } else { p.name = "小丽"; p.gender = "女"; } i++; } } } } // 消费者 class Consumer implements Runnable { Person p; public Consumer() { } public Consumer(Person p) { this.p = p; } @Override public void run() { while (true) { synchronized (p) { System.out.println("name:" + p.name + "---gnder:" + p.gender); } } } }
编译运行:屏幕没有再输出jack –女 或者小丽- man 这种情况了。说明我们解决了线程同步问题,但是仔细观察,生产者生产了若干次数据,消费者才开始取数据,或者消费者取出数据后,没有等到消费者放入新的数据,消费者又重复的取出自己已经去过的数据。这个问题依然存在。
升级:在Person类中添加两个方法,set和read方法并设置为synchronized的,让生产者和消费者调用这两个方法。
public class Demo10 { public static void main(String[] args) { Person p = new Person(); Producer pro = new Producer(p); Consumer con = new Consumer(p); Thread t1 = new Thread(pro, "生产者"); Thread t2 = new Thread(con, "消费者"); t1.start(); t2.start(); } } // 使用Person作为数据存储空间 class Person { String name; String gender; public synchronized void set(String name, String gender) { this.name = name; this.gender = gender; } public synchronized void read() { System.out.println("name:" + this.name + "----gender:" + this.gender); } } // 生产者 class Producer implements Runnable { Person p; public Producer() { } public Producer(Person p) { this.p = p; } @Override public void run() { int i = 0; while (true) { if (i % 2 == 0) { p.set("jack", "man"); } else { p.set("小丽", "女"); } i++; } } } // 消费者 class Consumer implements Runnable { Person p; public Consumer() { } public Consumer(Person p) { this.p = p; } @Override public void run() { while (true) { p.read(); } } }
需求:我们需要生产者生产一次,消费者就消费一次。然后这样有序的循环。
这就需要使用线程间的通信了。Java通过Object类的wait,notify,notifyAll这几个方法实现线程间的通信。
1.1 等待唤醒机制
wait:告诉当前线程放弃执行权,并放弃监视器(锁)并进入阻塞状态,直到其他线程持有获得执行权,并持有了相同的监视器(锁)并调用notify为止。
notify:唤醒持有同一个监视器(锁)中调用wait的第一个线程,例如,餐馆有空位置后,等候就餐最久的顾客最先入座。注意:被唤醒的线程是进入了可运行状态。等待cpu执行权。
notifyAll:唤醒持有同一监视器中调用wait的所有的线程。
如何解决生产者和消费者的问题?
可以通过设置一个标记,表示数据的(存储空间的状态)例如,当消费者读取了(消费了一次)一次数据之后可以将标记改为false,当生产者生产了一个数据,将标记改为true。
,也就是只有标记为true的时候,消费者才能取走数据,标记为false时候生产者才生产数据。
代码实现:
public class Demo10 { public static void main(String[] args) { Person p = new Person(); Producer pro = new Producer(p); Consumer con = new Consumer(p); Thread t1 = new Thread(pro, "生产者"); Thread t2 = new Thread(con, "消费者"); t1.start(); t2.start(); } } // 使用Person作为数据存储空间 class Person { String name; String gender; boolean flag = false; public synchronized void set(String name, String gender) { if (flag) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } this.name = name; this.gender = gender; flag = true; notify(); } public synchronized void read() { if (!flag) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("name:" + this.name + "----gender:" + this.gender); flag = false; notify(); } } // 生产者 class Producer implements Runnable { Person p; public Producer() { } public Producer(Person p) { this.p = p; } @Override public void run() { int i = 0; while (true) { if (i % 2 == 0) { p.set("jack", "man"); } else { p.set("小丽", "女"); } i++; } } } // 消费者 class Consumer implements Runnable { Person p; public Consumer() { } public Consumer(Person p) { this.p = p; } @Override public void run() { while (true) { p.read(); } } }
线程间通信其实就是多个线程在操作同一个资源,但操作动作不同,wait,notify(),notifyAll()都使用在同步中,因为要对持有监视器(锁)的线程操作,所以要使用在同步中,因为只有同步才具有锁。
为什么这些方法定义在Object类中
因为这些方法在操作线程时,都必须要标识他们所操作线程持有的锁,只有同一个锁上的被等待线程,可以被统一锁上notify唤醒,不可以对不同锁中的线程进行唤醒,就是等待和唤醒必须是同一个锁。而锁由于可以使任意对象,所以可以被任意对象调用的方法定义在Object类中
wait() 和 sleep()有什么区别?
wait():释放资源,释放锁。是Object的方法
sleep():释放资源,不释放锁。是Thread的方法
定义了notify为什么还要定义notifyAll,因为只用notify容易出现只唤醒本方线程情况,导致程序中的所有线程都在等待。
注意:
1.wait方法与notify方法是属于Object对象的。
2.wait方法与notify方法必须在同步代码块或同步函数中才能使用。
3.wait方法与notify方法必须要有锁对象来调用。