Java多线程 二 线程间通信

红太狼 2021-11-01 08:32 522阅读 0赞

线程间通信：

多个线程在处理同一资源，但是

等待唤醒机制

涉及的方法：

1、wait() 让线程处于冻结状态，被wait的线程会被存储到线程池中。

2、notify() 唤醒线程池中的一个线程（任意）

3、notifyAll() 唤醒线程池中的所有线程、、

这些方法都必须定义在同步中，

因为这些方法是用于操作线程状态的方法。

必须明确到底操作的那个锁上的线程。

为什么操作线程的方法wait notify notifyAll定义在了Object中。

因为这些方法是监视器方法，监视器其实就是锁。

锁可以是任意的对象，任意的对象调用的方法一定定义在Object类中。

  1. package com.pzq.thread;
  3. public class SyncDemo3 {
  5.     public static void main(String[] args) {
  7.         Resource resource = new Resource();
  8.         Input input = new Input(resource);
  9.         OutPut outPut = new OutPut(resource);
  10.         Thread threadInput = new Thread(input);
  11.         Thread threadOuput = new Thread(outPut);
  12.         threadInput.start();
  13.         threadOuput.start();
  14.     }
  16. }
  18. class Input implements Runnable {
  20.     Resource r;
  22.     public Input(Resource r) {
  23.         this.r = r;
  24.     }
  26.     @Override
  27.     public void run() {
  28.         int x = 0;
  29.         while (true) {
  30.             synchronized (r) {
  32.                 if (r.flag) {
  33.                     try {
  34.                         r.wait();
  35.                     } catch (InterruptedException e) {
  36.                         e.printStackTrace();
  37.                     }
  38.                 }
  39.                 if (x == 0) {
  40.                     r.name = "mike";
  41.                     r.sex = "nan";
  42.                 } else {
  43.                     r.name = "丽丽";
  44.                     r.sex = "女女女女女女女";
  45.                 }
  46.                 r.flag = true;
  47.                 r.notify();
  48.             }
  49.             x = (x + 1) % 2;
  50.         }
  51.     }
  53. }
  55. class OutPut implements Runnable {
  57.     Resource r;
  59.     public OutPut(Resource r) {
  60.         this.r = r;
  61.     }
  63.     @Override
  64.     public void run() {
  65.         while (true) {
  66.             synchronized (r) {
  67.                 if (!r.flag) {
  68.                     try {
  69.                         r.wait();
  70.                     } catch (InterruptedException e) {
  71.                         e.printStackTrace();
  72.                     }
  73.                 }
  74.                 System.out.println(r.name + "......" + r.sex);
  75.                 r.flag = false;
  76.                 r.notify();
  77.             }
  78.         }
  79.     }
  81. }
  83. class Resource {
  84.     String name;
  85.     String sex;
  86.     boolean flag = false;
  88.     public Resource() {
  89.     }
  91.     public Resource(String name, String sex) {
  92.         this.name = name;
  93.         this.sex = sex;
  94.     }
  95. }

生产者消费者

代码优化，将同步方法封装到属性当中

  1. package com.pzq.thread;
  3. public class SyncDemo3 {
  5.     public static void main(String[] args) {
  7.         Resource resource = new Resource();
  8.         Input input = new Input(resource);
  9.         OutPut outPut = new OutPut(resource);
  10.         Thread threadInput = new Thread(input);
  11.         Thread threadOuput = new Thread(outPut);
  12.         threadInput.start();
  13.         threadOuput.start();
  14.     }
  16. }
  18. class Input implements Runnable {
  20.     Resource r;
  22.     public Input(Resource r) {
  23.         this.r = r;
  24.     }
  26.     @Override
  27.     public void run() {
  28.         int x = 0;
  29.         while (true) {
  30.             if (x == 0) {
  31.                 r.set("mike", "nan");
  32.             } else {
  33.                 r.set("丽丽", "=========女");
  34.             }
  35.             x = (x + 1) % 2;
  36.         }
  37.     }
  39. }
  41. class OutPut implements Runnable {
  43.     Resource r;
  45.     public OutPut(Resource r) {
  46.         this.r = r;
  47.     }
  49.     @Override
  50.     public void run() {
  51.         while (true) {
  52.             r.out();
  53.         }
  54.     }
  56. }
  58. class Resource {
  59.     private String name;
  60.     private String sex;
  61.     private boolean flag = false;
  63.     public Resource() {
  64.     }
  66.     public synchronized void set(String name, String sex) {
  67.         if (flag) {
  68.             try {
  69.                 this.wait();
  70.             } catch (InterruptedException e) {
  71.                 e.printStackTrace();
  72.             }
  73.         }
  74.         this.name = name;
  75.         this.sex = sex;
  76.         flag = true;
  77.         this.notify();
  78.     }
  80.     public synchronized void out() {
  81.         if (!flag) {
  82.             try {
  83.                 this.wait();
  84.             } catch (InterruptedException e) {
  85.                 e.printStackTrace();
  86.             }
  87.         }
  88.         System.out.println(this.name + "....." + this.sex);
  89.         flag = false;
  90.         this.notify();
  91.     }
  93. }

单生产单消费

  1. package com.pzq.thread;
  3. public class SyncDemo4 {
  5.     public static void main(String[] args) {
  7.         Resource2 resource = new Resource2();
  8.         Producter input = new Producter(resource);
  9.         Customer outPut = new Customer(resource);
  10.         Thread threadInput = new Thread(input);
  11.         Thread threadOuput = new Thread(outPut);
  12.         threadInput.start();
  13.         threadOuput.start();
  14.     }
  16. }
  18. class Producter implements Runnable {
  20.     Resource2 r;
  22.     public Producter(Resource2 r) {
  23.         this.r = r;
  24.     }
  26.     @Override
  27.     public void run() {
  28.         while (true) {
  29.             r.set("烤鸭");
  30.         }
  31.     }
  33. }
  35. class Customer implements Runnable {
  37.     Resource2 r;
  39.     public Customer(Resource2 r) {
  40.         this.r = r;
  41.     }
  43.     @Override
  44.     public void run() {
  45.         while (true) {
  46.             r.out();
  47.         }
  48.     }
  50. }
  52. class Resource2 {
  53.     private String name;
  54.     private boolean flag = false;
  55.     private int count = 1;
  57.     public Resource2() {
  58.     }
  60.     public synchronized void set(String name) {
  61.         if (flag) {
  62.             try {
  63.                 this.wait();
  64.             } catch (InterruptedException e) {
  65.                 e.printStackTrace();
  66.             }
  67.         }
  68.         this.name = name + count;
  69.         count++;
  70.         System.out.println(Thread.currentThread().getName() + "生产者+++" + this.name);
  71.         flag = true;
  72.         this.notify();
  73.     }
  75.     public synchronized void out() {
  76.         if (!flag) {
  77.             try {
  78.                 this.wait();
  79.             } catch (InterruptedException e) {
  80.                 e.printStackTrace();
  81.             }
  82.         }
  83.         System.out.println(Thread.currentThread().getName() + "消费者" + "=================" + this.name);
  84.         flag = false;
  85.         this.notify();
  86.     }
  88. }

多生产者多消费者

if判断标记，只有一次，会导致不该运行的线程运行了。出现了数据错误的情况。

while判断标记，解决了线程获取执行权后，是否要运行

notify只能唤醒一个线程，如果本方唤醒了本方，就没有意义了。而且 while判断标记+notify会导致死锁。

notifyAll解决了，本方线程一定会唤醒对方线程。

  1. package com.pzq.thread;
  3. public class SyncDemo4 {
  5.     public static void main(String[] args) {
  7.         Resource2 resource = new Resource2();
  8.         Producter input = new Producter(resource);
  9.         Customer outPut = new Customer(resource);
  10.         Thread threadInput1 = new Thread(input);
  11.         Thread threadInput2 = new Thread(input);
  12.         Thread threadInput3 = new Thread(input);
  13.         Thread threadOuput1 = new Thread(outPut);
  14.         Thread threadOuput2 = new Thread(outPut);
  15.         Thread threadOuput3 = new Thread(outPut);
  16.         Thread threadOuput4 = new Thread(outPut);
  17.         Thread threadOuput5 = new Thread(outPut);
  18.         threadInput1.start();
  19.         threadInput2.start();
  20.         threadInput3.start();
  21.         threadOuput1.start();
  22.         threadOuput2.start();
  23.         threadOuput3.start();
  24.         threadOuput4.start();
  25.         threadOuput5.start();
  26.     }
  28. }
  30. class Producter implements Runnable {
  32.     Resource2 r;
  34.     public Producter(Resource2 r) {
  35.         this.r = r;
  36.     }
  38.     @Override
  39.     public void run() {
  40.         while (true) {
  41.             r.set("烤鸭");
  42.         }
  43.     }
  45. }
  47. class Customer implements Runnable {
  49.     Resource2 r;
  51.     public Customer(Resource2 r) {
  52.         this.r = r;
  53.     }
  55.     @Override
  56.     public void run() {
  57.         while (true) {
  58.             r.out();
  59.         }
  60.     }
  62. }
  64. class Resource2 {
  65.     private String name;
  66.     private boolean flag = false;
  67.     private int count = 1;
  69.     public Resource2() {
  70.     }
  72.     public synchronized void set(String name) {
  73.         while (flag) {
  74.             try {
  75.                 this.wait();
  76.             } catch (InterruptedException e) {
  77.                 e.printStackTrace();
  78.             }
  79.         }
  80.         this.name = name + count;
  81.         count++;
  82.         System.out.println(Thread.currentThread().getName() + "生产者+++" + this.name);
  83.         flag = true;
  84.         this.notifyAll();
  85.     }
  87.     public synchronized void out() {
  88.         while (!flag) {
  89.             try {
  90.                 this.wait();
  91.             } catch (InterruptedException e) {
  92.                 e.printStackTrace();
  93.             }
  94.         }
  95.         System.out.println(Thread.currentThread().getName() + "消费者" + "=================" + this.name);
  96.         flag = false;
  97.         this.notifyAll();
  98.     }
  100. }

多生产者多消费者 1.5新特性

jdk1.5以后将同步和锁封装成了对象。

并将操作锁的隐式方式定义到了该对象中，

将隐式动作变成了显示动作。

Lock接口：出现了替代同步代码块或者同步函数。将同步的隐式锁操作变成现实锁操作。

同时更为灵活，可以一个锁上加上多组监视器。

lock() 获取锁

unlock()：释放锁，通常需要定义finally代码块中

Condition接口：出现替代了Object中的wait notify notifyAll方法。

　　将这些监视器方法单独进行了封装，变成Condition监视器对象。

　　可以任意锁进行组合。

await();

signal();

singnalAll

  1. package com.pzq.thread;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. public class SyncDemo4 {
  9.     public static void main(String[] args) {
  11.         Resource2 resource = new Resource2();
  12.         Producter input = new Producter(resource);
  13.         Customer outPut = new Customer(resource);
  14.         Thread threadInput1 = new Thread(input);
  15.         Thread threadInput2 = new Thread(input);
  16.         Thread threadInput3 = new Thread(input);
  17.         Thread threadOuput1 = new Thread(outPut);
  18.         Thread threadOuput2 = new Thread(outPut);
  19.         Thread threadOuput3 = new Thread(outPut);
  20.         Thread threadOuput4 = new Thread(outPut);
  21.         Thread threadOuput5 = new Thread(outPut);
  22.         threadInput1.start();
  23.         threadInput2.start();
  24.         threadInput3.start();
  25.         threadOuput1.start();
  26.         threadOuput2.start();
  27.         threadOuput3.start();
  28.         threadOuput4.start();
  29.         threadOuput5.start();
  30.     }
  32. }
  34. class Producter implements Runnable {
  36.     Resource2 r;
  38.     public Producter(Resource2 r) {
  39.         this.r = r;
  40.     }
  42.     @Override
  43.     public void run() {
  44.         while (true) {
  45.             r.set("烤鸭");
  46.         }
  47.     }
  49. }
  51. class Customer implements Runnable {
  53.     Resource2 r;
  55.     public Customer(Resource2 r) {
  56.         this.r = r;
  57.     }
  59.     @Override
  60.     public void run() {
  61.         while (true) {
  62.             r.out();
  63.         }
  64.     }
  66. }
  68. class Resource2 {
  69.     private String name;
  70.     private boolean flag = false;
  71.     private int count = 1;
  73.     // 创建一个锁对象
  74.     Lock lock = new ReentrantLock();
  75.     // 通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者
  76.     Condition con_producter = lock.newCondition();
  77.     Condition con_customer = lock.newCondition();
  79.     public Resource2() {
  80.     }
  82.     public void set(String name) {
  83.         lock.lock();
  84.         try {
  85.             while (flag) {
  86.                 try {
  87.                     con_producter.await();
  88.                 } catch (InterruptedException e) {
  89.                     e.printStackTrace();
  90.                 }
  91.             }
  92.             this.name = name + count;
  93.             count++;
  94.             System.out.println(Thread.currentThread().getName() + "生产者+++" + this.name);
  95.             flag = true;
  96.             con_customer.signal();
  97.         } finally {
  98.             lock.unlock();
  99.         }
  101.     }
  103.     public void out() {
  104.         lock.lock();
  105.         try {
  106.             while (!flag) {
  107.                 try {
  108.                     con_customer.await();
  109.                 } catch (InterruptedException e) {
  110.                     e.printStackTrace();
  111.                 }
  112.             }
  113.             System.out.println(Thread.currentThread().getName() + "消费者" + "=================" + this.name);
  114.             flag = false;
  115.             con_producter.signal();
  117.         } finally {
  118.             lock.unlock();
  119.         }
  121.     }
  123. }

定义一个容器的生产者消费者

  1. package com.pzq.thread;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. public class BoundBuffer {
  8.     public static void main(String[] args) {
  10.         Resources resources = new Resources();
  12.         Products products = new Products(resources);
  13.         Customers customers = new Customers(resources);
  15.         new Thread(products).start();
  16.         new Thread(products).start();
  17.         new Thread(products).start();
  18.         new Thread(customers).start();
  19.         new Thread(customers).start();
  20.         new Thread(customers).start();
  22.     }
  24. }
  26. class Customers implements Runnable {
  27.     Resources rs;
  29.     public Customers(Resources rs) {
  30.         this.rs = rs;
  31.     }
  33.     @Override
  34.     public void run() {
  35.         while (true) {
  36.             try {
  37.                 rs.take();
  38.                 Thread.sleep(1000);
  39.             } catch (InterruptedException e) {
  40.                 e.printStackTrace();
  41.             }
  42.         }
  43.     }
  45. }
  47. class Products implements Runnable {
  48.     Resources rs;
  50.     int count = 1;
  52.     public Products(Resources rs) {
  53.         this.rs = rs;
  54.     }
  56.     @Override
  57.     public void run() {
  58.         while (true) {
  59.             try {
  60.                 rs.put("烤鸭");
  61.                 Thread.sleep(1000);
  62.             } catch (InterruptedException e) {
  63.                 e.printStackTrace();
  64.             }
  65.         }
  66.     }
  68. }
  70. class Resources {
  71.     Lock lock = new ReentrantLock();
  72.     Condition notEmpty = lock.newCondition();
  73.     Condition notFull = lock.newCondition();
  74.     Object[] buffer = new Object[100];
  75.     int putptr, takeptr, count;
  77.     public void put(Object x) throws InterruptedException {
  78.         lock.lock();
  79.         try {
  80.             while (count == buffer.length) {
  81.                 notFull.await();
  82.             }
  83.             buffer[putptr] = x;
  84.             if (++putptr == buffer.length) {
  85.                 putptr = 0;
  86.             }
  87.             ++count;
  88.             System.out.println("-------" + Thread.currentThread().getName() + "生产了---" + (x.toString() + putptr));
  89.             notEmpty.signal();
  91.         } finally {
  92.             lock.unlock();
  93.         }
  94.     }
  96.     public void take() throws InterruptedException {
  97.         lock.lock();
  98.         // Object x = null;
  99.         try {
  100.             while (count == 0) {
  101.                 notEmpty.await();
  102.             }
  103.             Object x = buffer[takeptr];
  104.             if (++takeptr == buffer.length) {
  105.                 takeptr = 0;
  106.             }
  107.             --count;
  108.             System.out.println("#######" + Thread.currentThread().getName() + "消费了####" + (x.toString() + takeptr));
  110.             notFull.signal();
  112.         } finally {
  113.             lock.unlock();
  114.         }
  115.         // return x;
  116.     }
  117. }

wait和sleep区别

1、wait可以指定时间也可以不指定。

　　sleep必须指定时间

2、在同步中时，对CPU的执行权和锁的处理不同

　　wait：释放执行权，释放锁

　　sleep:释放执行权，不释放锁

停止线程

1、run方法结束：线程中的任务结束了，线程就停止了。

2、可以使用interrupt()方法将线程从冻结状态强制回鹘到运行状态中，让线程具备cpu的执行资格

  1.  当强制动作发生了InterruputdException,设置标记。
  3. package com.pzq.thread;
  5. public class SyncDemo5 {
  7.     public static void main(String[] args) {
  8.         StopRunnable stop = new StopRunnable();
  10.         Thread thread1 = new Thread(stop);
  11.         Thread thread2 = new Thread(stop);
  13.         thread1.start();
  14.         thread2.start();
  15.         thread1.interrupt();
  16.         thread2.interrupt();
  17.     }
  19. }
  21. class StopRunnable implements Runnable {
  23.     boolean flag = true;
  25.     @Override
  26.     public synchronized void run() {
  27.         while (flag) {
  28.             try {
  29.                 wait();
  30.             } catch (InterruptedException e) {
  31.                 System.out.println(Thread.currentThread().getName() + " , " + e);
  32.                 setFlagFalse();
  33.             }
  34.             System.out.println(Thread.currentThread().getName() + " ..... ");
  35.         }
  36.     }
  38.     public void setFlagFalse() {
  39.         flag = false;
  40.     }
  42. }

线程中常见方法

setDaemon: 将该线程标记为守护线程（后台线程）或用户线程，当正在运行的线程都是守护线程时java虚拟机退出。该方法必须在启动线程前调用。

　　　　　　该方法首先调用线程的 checkAccess方法，且不带任何参数。这可能抛出SecurityException（当前线程中）

join 调用join时说明线程要申请加入进来运行。主线程会将执行权释放出来。等待thread1执行完。只要thread1执行完主线程就可以执行。

  1. //临时加入一个线程运算时可以用到join方法
  3. package com.pzq.thread;
  5. public class JoinDemo {
  7.     public static void main(String[] args) {
  8.         TestRun testRun = new TestRun();
  9.         Thread thread1 = new Thread(testRun);
  10.         Thread thread2 = new Thread(testRun);
  12.         thread1.start();
  13.         try {
  14.             thread1.join(); //thread1线程要申请加入进来运行。主线程会将执行权释放出来。等待thread1执行完。只要thread1执行完主线程就可以执行。
  15.             //临时加入一个线程运算时可以用到join方法
  16.         } catch (InterruptedException e) {
  17.             e.printStackTrace();
  18.         }
  19.         thread2.start();
  21.         for (int x = 0; x < 50; x++) {
  22.             System.out.println(Thread.currentThread().getName() + " ... " + x);
  23.         }
  25.     }
  26. }
  28. class TestRun implements Runnable {
  30.     @Override
  31.     public void run() {
  32.         for (int i = 0; i < 50; i++) {
  33.             System.out.println(Thread.currentThread().getName() + " ... " + i);
  34.         }
  35.     }
  37. }

setPriority 设置线程优先级

yield:释放自己的执行权

转载于:https://www.cnblogs.com/qiangge-python/p/11067391.html

发表评论

表情：
评论列表 （有 0 条评论，522人围观）

还没有评论，来说两句吧...

相关阅读