多线程是什么

  • 多线程是指从软硬件上实现多条执行流程的技术
  • 多线程：
    • 继承Thread类
    • 实现Runnable接口
  • 不要把主线程任务放在子线程之前，要不然就是单一线程

方式一：

  • 继承Thread类； 重写run方法； 创建线程对象； 调用start方法启动
  • 优缺点：优点编码简单 缺点：存在单继承的局限性，线程类继承Thread后不能继承其他类，不便于扩展。

启动线程调用start()；调用run就是普通调用

  1. //线程的开始
  2. public class ThreadTest {
  3.     public static void main(String[] args) {
  4.         //创建线程对象
  5.         Thread ct = new CreateThread();
  6.         //调用start 启动线程
  7.         ct.start();
  8.         for (int i = 0; i < 10; i++) {
  9.             System.out.println("主线程"+i);
  10.         }
  11.     }
  12. }
  13. /*
  14. *   多线程的创建方式之一：继承Thread类实现
  15. * */
  16. public class CreateThread extends Thread{
  18.     /*
  19.     *   重写run方法，里面是定义线程以后要干啥
  20.     * */
  21.     @Override
  22.     public void run() {
  23.         for (int i = 0; i < 10; i++) {
  24.             System.out.println("子线程"+i);
  25.         }
  26.     }
  27. }

多线程的实现方案二：实现Runnable接口

  1. 定义一个线程任务类MyRunnable实现Runnable接口，实现run()方法
  2. 创建线程任务对象MyRunnable
  3. 把MyRunnable任务对象交给Thread处理
  4. 调用线程对象的start()方法启动线程

Runnable接口：

  • 优缺点：
    • 优：线程任务类只是实现接口，可以继承类和实现接口，扩展性强。
    • 缺：编程多一层对象包装，如果线程执有执行结果是不可以直接返回的
    • 第一种和第二种都是没有返回结果的 ```java package com.h.runnable; /*
  • 第二种线程创建方式
  • */ public class Test { public static void main(String[] args) {
    1.   //创建一个任务对象
    2.   Runnable ctr = new CreatThreadRunnable();
    3.   //把任务对象交给线程对象
    4.   new Thread(ctr).start();
    5.   for (int i = 0; i < 5; i++) {
    6.       System.out.println("主线程"+i);
    7.   }
    } } 实现的接口 package com.h.runnable;

/实现Runnable接口/ public class CreatThreadRunnable implements Runnable{ /*

  1. * 重写run方法
  2. *
  3. * */
  4. @Override
  5. public void run() {
  6.     for (int i = 0; i < 5; i++) {
  7.         System.out.println("子线程"+i);
  8.     }
  9. }

}

  1. 实现Runnable(匿名内部类)<br />写法：
  2. ```java
  3. public class InnerRunnable {
  4.     public static void main(String[] args) {
  5.         Runnable target = new Runnable(){
  6.           public void run(){
  7.               for (int i = 0; i < 5; i++) {
  8.                   System.out.println("匿名内部类线程"+i);
  9.               }
  10.             }
  11.         };
  12.         new Thread(target).start();
  13.         for (int i = 0; i < 5; i++) {
  14.             System.out.println("主线程"+i);
  15.         }
  16.     }
  17. }
  19. 简化
  20. public class InnerRunnable {
  22.     public static void main(String[] args) {
  24.         new Thread(new Runnable(){
  25.             public void run(){
  26.                 for (int i = 0; i < 5; i++) {
  27.                     System.out.println("匿名内部类线程"+i);
  28.                 }
  29.             }
  30.         }).start();       
  31.         for (int i = 0; i < 5; i++) {
  32.             System.out.println("主线程"+i);
  33.         }
  34.     }
  35. }
  37.         //使用Lambda表达式简化
  38.         new Thread(()->{
  39.                 for (int i = 0; i < 5; i++) {
  40.                     System.out.println("匿名内部类线程"+i);
  41.                 }
  42.         }).start();

方式三：
JDK5.0提供：Callable和FutureTask来实现

  • 前两种方式重写run方法均不能直接返回结果
  • 不适合需要返回线程执行结果的业务场景

实现方案三：

  1. 得到任务对象
    1. 定义类实现Callable接口，重写call方法，封装要做的事情。
    2. 用FutureTask把Callable对象封装成线程任务对象
  2. 把线程任务对象交给Thread处理
  3. 调用Thread的start方法启动线程，执行任务

  4. 线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果

    线程返回值需要怎么做：

  5. 创建任务对象MyCallable并实现Callable接口 泛型自己需要什么类型返回申明什么类型

  6. 重写call方法 并返回你所需要的值
  7. 到主线程创建Callable任务对象 Callable call = new MyCallable(100);
  8. 把Callable任务对象交给FutureTask对象
    1. FutureTask对象实现了RunnableFuture接口
    2. RunnableFuture继承了Runnable接口
    3. 所以Thread类构造器中可以放FutureTask对象
    4. FutureTask可以使用get方法来获取Callable所返回的值
  9. 把FutureTask交给Thread
  10. Thread类调用start方法启动线程
  11. FutureTask对象调用get()方法获取call()方法返回的值
  12. get方法返回两个结果一个是正常结果，另一个是异常结果所以得使用try{}catch(){}
  13. get()方法有一个监测就是看call方法是否跑完没有如果没有跑完，代码执行到调用get()方法的时候就会等待，等待跑完后才会提取结果

FutureTask的API:
public FutureTask<>(Callable call);把Callable对象封装成FutureTask对象；
public V get() throws Exception; 获取线程执行call方法返回的结果。如果线程没有执行完，就会等待
优点：

  • 线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强
  • 可以在线程执行完毕后去获取线程执行结果
    • 缺点
  • 编码复杂

代码：

  1. package com.h.callable;
  3. import java.util.concurrent.Callable;
  4. import java.util.concurrent.ExecutionException;
  5. import java.util.concurrent.FutureTask;
  7. /*
  8. * 学会线程创建方式三、实现Callable接口，结合FutureTask完成
  9. * */
  10. public class CallableTest {
  11.     public static void main(String[] args) {
  12.         //创建Callable任务对象
  13.         Callable<String> mc = new MyCallable(100);
  14.         //把Callable任务对象，封装给FutureTask对象
  15.         //为什么要交给FutureTask对象因为
  17.         // 作用1、FutureTask是Runnable对象(实现了Runnable接口)，可以交给Thread了
  18.         // 作用2、可以在线程执行完毕之后通过调用其get方法得到线程执行完完成的结果
  19.         FutureTask<String> ft = new FutureTask<>(mc);
  20.         Thread th = new Thread(ft);
  21.         th.start();
  22.         try{
  23.             String str = ft.get();
  24.             System.out.println("第一个结果"+str);
  25.         }
  27.     }
  28. }
  30. /*
  31. * 1、定义一个任务类，实现Callable类 应该申明线程任务执行完毕后的结果的数据类型
  32. * */
  33. class MyCallable implements Callable<String> {
  34.     private  int n;
  36.     public MyCallable(int n) {
  37.         this.n = n;
  38.     }
  40.     /*重写call方法 线程任务方法*/
  41.     @Override
  42.     public String call() throws Exception {
  43.         int sum  = 0;
  44.         for (int i = 0; i <= n; i++) {
  45.             sum+=i;
  46.         }
  47.         return "子线程的结果是" +sum;
  48.     }
  49. }

Thread常见方法
给线程设置名字

  1. 使用Thread.setName();
  2. 使用构造器来给线程设置名字

获取线程名字

  1. 使用Thread.getName();

获取当前线程的方法：
谁调用的，谁就是当前线程

  • Thread.currentThread();

使用Runnable的时候进行设置名称

  • new Thread(Runnable runnable,String name);

线程休眠：

  • Thread.sleep(long time);当前线程休眠指定的时间后再继续执行，单位为毫秒 ```java

public class MyThreadTest { public static void main(String[] args) { Thread t1 =new MyThread(“构造器1号”); //给线程取名字 t1.setName(“1号”); t1.start();

  1.     //拿到当前线程对象
  2.     Thread m = Thread.currentThread();
  3.     m.setName("主线程");
  4.     for (int i = 0; i < 5; i++) {
  5.         System.out.println(m.getName()+""+i);
  6.     }
  7. }

}

public class MyThread extends Thread{ //使用构造器给线程设置名字 public MyThread(String name) { super(name); }

  1. @Override
  2. public void run() {
  3.     for (int i = 0; i < 5; i++) {
  4.         //获取线程名字
  5.         System.out.println(Thread.currentThread().getName()+"子线程");
  6.     }
  7. }

}

  1. <a name="UoKwb"></a>
  2. #### 线程安全问题：
  4. - **多个线程同时操作同一个共享资源**的时候可能会出现业务安全问题，称为线程安全问题
  5. - 同步代码块
  7. 代码：
  8. ```java
  9. package com.h.h_account;
  11. public class Account {
  12.     private String cardId;
  13.     private double money;
  15.     public Account() {
  16.     }
  18.     public Account(double money) {
  19.         this.money = money;
  20.     }
  22.     public Account(String cardId, double money) {
  23.         this.cardId = cardId;
  24.         this.money = money;
  25.     }
  27.     public String getCardId() {
  28.         return cardId;
  29.     }
  31.     public void setCardId(String cardId) {
  32.         this.cardId = cardId;
  33.     }
  35.     public double getMoney() {
  36.         return money;
  37.     }
  39.     public void setMoney(double money) {
  40.         this.money = money;
  41.     }
  43.     public void drawMoney(double money) {
  44.         //获取当前线程是谁在调用
  45.         String name = Thread.currentThread().getName();
  47.         //判断账户余额是否足够
  48.         if(this.money>= money){
  49.             //取钱
  50.             System.out.println(name + "取钱："+money);
  51.             this.money -= money;
  52.             System.out.println("当前剩余余额："+this.money);
  53.         }else {
  54.             System.out.println("余额不足");
  55.         }
  56.     }
  57. }
  59. package com.h.h_account;
  61. /*
  62. * 取钱的线程
  63. * */
  64. public class DrawThread extends Thread{
  66.     private Account acc;
  68.     public DrawThread(Account acc,String name) {
  69.         super(name);
  70.         this.acc = acc;
  71.     }
  73.     @Override
  74.     public void run() {
  75.         //同时取钱
  76.         acc.drawMoney(100);
  77.     }
  80. }
  82. package com.h.h_account;
  84. public class AccountTest {
  86.     public static void main(String[] args) {
  87.         /*小明与小红共同使用一个账户*/
  89.         Account ac = new Account(100);
  90.         Thread t1 = new DrawThread(ac ,"小明");
  92.         Thread t2 = new DrawThread(ac,"小红");
  94.         t1.start();
  95.         t2.start();
  97.     }
  99. }
  101. 同步锁解决问题
  102.  //在这加锁的 然后当两个线程到这的时候只能有一个线程能抢到，抢到以后另一个线程就等待
  103.  synchronized ("hh") {
  104.      if (this.money >= money) {
  105.          //取钱
  106.          System.out.println(name + "取钱：" + money);
  107.          this.money -= money;
  108.          System.out.println("当前剩余余额：" + this.money);
  109.      } else {
  110.          System.out.println("余额不足");
  111.      }
  112.  }

解决上面线程安全问题：线程同步
线程同步核心思想

  • 加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来
  • 作用：把出现线程安全问题的核心代码给上锁
  • 原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行

synchronized(同步锁对象){
操作共享资源的代码(核心代码)
}
锁对象要求

  • 理论上：锁对象只要对于当前同时执行的线程来说是同一个对象即可

锁对象用任意唯一的对象不好

  • 会影响其他无关线程的执行 
  1. 同步锁解决问题
  2.  //在这加锁的 然后当两个线程到这的时候只能有一个线程能抢到，抢到以后另一个线程就等待
  3.  synchronized (this) {
  4.      if (this.money >= money) {
  5.          //取钱
  6.          System.out.println(name + "取钱：" + money);
  7.          this.money -= money;
  8.          System.out.println("当前剩余余额：" + this.money);
  9.      } else {
  10.          System.out.println("余额不足");
  11.      }
  12.  }

锁对象的规范要求

  • 规范上：建议使用共享资源作为锁对象。
  • 对于实例方法建议使用this作为锁对象
  • 对于静态方法建议使用字节码(类名.class)对象作为锁对象。

静态方法

  1. class Acc{
  2.     //100个线程来也只有一个人能拿到
  3.     public static void run(){
  4.          synchronized(Acc.class)   
  5.     }
  6. }

synchronized (“hh”)这样写是唯一性所有线程都必须从他这拿锁
synchronized (this)这样写是每个对象拿自己的那把锁，其他线程不受干扰
为什么写this呢
因为this是那个类所调用的那个方法传过来的对象
问题：

  1. 同步代码块是如何实现线程安全的？
    1. 对出现问题的核心代码使用synchronzed()进行加锁
    2. 每次只能一个线程占锁进入访问
  2. 同步代码块的同步锁对象有什么要求？
    1. 对于实例化方法建议使用this作为锁对象
    2. 对于静态方法建议使用字节码(类名.class)对象作为锁对象

END

同步方法：
同步锁可以作为修饰符加上
同步方法的底层原理

  • 同步方法与同步代码块原理一样 只是不需要你自己添加this或类名.class

    1. class Acc{
    2.   //同步方法
    3.   public synchronized void run(){
    4.        //核心代码块 
    5.   }
    6. }

    性能方面：同步代码块可以选择你所想锁的代码 同步方法是将整个方法锁起来,性能方面差别微乎其微。
    同步代码块 与 同步方法原理一样
    实际开发中同步方法使用较多因为代码简单

    LOCK锁：

    创建方式：
    把锁写在类里面，每次new类的时候都会创建出一个锁

  • Lock lock = new ReentrantLock();

  • Lock是接口ReentrantLock是Lock的实现类
  • lock.lock();//上锁
  • lock.unlock();//解锁

看代码：

  1. package com.h.h_lock;
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  6. public class Account {
  7.     private String cardId;
  8.     private double money;
  9.     //自创锁   唯一不可替换锁 非常专业 每次创建对象都有一个锁
  10.     private final Lock lock = new ReentrantLock();
  12.     public Account() {
  13.     }
  15.     public Account(double money) {
  16.         this.money = money;
  17.     }
  19.     public Account(String cardId, double money) {
  20.         this.cardId = cardId;
  21.         this.money = money;
  22.     }
  24.     public String getCardId() {
  25.         return cardId;
  26.     }
  28.     public void setCardId(String cardId) {
  29.         this.cardId = cardId;
  30.     }
  32.     public double getMoney() {
  33.         return money;
  34.     }
  36.     public void setMoney(double money) {
  37.         this.money = money;
  38.     }
  41.     //在核心代码块上调用lock方法就上锁
  42.     public void drawMoney(double money) {
  43.         //获取当前线程是谁在调用
  44.         String name = Thread.currentThread().getName();
  45.         //为了代码的强健性加上finally
  46.             lock.lock(); //上锁
  47.         try {
  48.             if (this.money >= money) {
  49.                 //取钱
  50.                 System.out.println(name + "取钱：" + money);
  51.                 this.money -= money;
  52.                 System.out.println("当前剩余余额：" + this.money);
  53.             } else {
  54.                 System.out.println("余额不足");
  55.             }
  56.         }finally {
  57.             //加锁核心代码出现异常，而不会影响解锁
  58.             lock.unlock();//解锁
  59.         }
  61.     }
  62. }

线程池(重点)

谁代表线程池

  • ExecutorService接口

线程池概述：

  • 线程池就是一个可以复用线程的技术，反复使用；

不使用线程池的问题

  • 如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务又来了又要创建新线程，而这样创建开销是很大的，这样会严重影响系统性能，所以我们需要用线程池。

如何得到线程池

  • 方式一：使用ExecutorService的实现类ThreadPoolExecutor创建一个线程池
  • 方式二：使用Executors(线程池的工具类)调用方法返回不同的特点的线程池对象

构造器：
七个参数

image.png

线程池常见面试题：

临时线程什么时候创建啊？

  • 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
  • 什么是还可以创建临时线程
    • 当线程池给的最大线程数还小于等于当前线程的时候还可以创建

什么时候会开始拒绝任务

  • 核心线程与临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

Runnable添加进线程池：

  1. package com.h.h_threadpool;
  2. import java.util.concurrent.*;
  4. /*
  5. *   自定义线程池对象，并测试特性
  6. * */
  7. public class ThreadPoolDemo1 {
  8.     //1、创建线程池对象
  10.     /*int corePoolSize,
  11.       int maximumPoolSize,
  12.       long keepAliveTime,
  13.       TimeUnit unit,
  14.       BlockingQueue<Runnable> workQueue,
  15.       ThreadFactory threadFactory,
  16.       RejectedExecutionHandler handler
  17.    */
  18.     public static void main(String[] args) {
  19.         ExecutorService es = new ThreadPoolExecutor(3,5,6,
  20.                 TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
  21.                 new ThreadPoolExecutor.AbortPolicy());
  22.         //2、给任务线程池处理
  23.         Runnable runnable = new MyRunnable();
  24.         //把线程丢入线程池  核心线程3个
  25.         es.execute(runnable);
  26.         es.execute(runnable);
  27.         es.execute(runnable);
  29.         //新任务排队5个
  30.         es.execute(runnable);
  31.         es.execute(runnable);
  32.         es.execute(runnable);
  33.         es.execute(runnable);
  34.         es.execute(runnable);
  36.         //临时线程
  37.         es.execute(runnable);
  38.         es.execute(runnable);
  40.         //不创建 拒绝策略被触发
  41. //        es.execute(runnable);
  43.         //关闭线程池 开发中一般不会使用
  44. //        es.shutdownNow(); //立即关闭 即使任务没有完成
  45. //        es.shutdown(); //等待任务完成以后才能关闭
  47.     }
  49. }
  51. Runnable线程
  52. package com.h.h_threadpool;
  54. public class MyRunnable implements Runnable {
  57.     public void run() {
  58.         for (long i = 0; i < 5; i++) {
  59.             System.out.println(Thread.currentThread().getName()+"输出了Hello World"+i);
  61.         }
  63.         try {
  64.             Thread.sleep(100000);
  65.         } catch (InterruptedException e) {
  66.             e.printStackTrace();
  67.         }
  68.     }
  69. }

Callable添加进线程池

  1. package com.h.h_threadpool;
  3. import java.util.concurrent.*;
  5. /*
  6. *   自定义线程池对象，并测试特性
  7. * */
  8. public class ThreadPoolDemo2 {
  9.     //1、创建线程池对象
  11.     /*int corePoolSize,
  12.       int maximumPoolSize,
  13.       long keepAliveTime,
  14.       TimeUnit unit,
  15.       BlockingQueue<Runnable> workQueue,
  16.       ThreadFactory threadFactory,
  17.       RejectedExecutionHandler handler
  18.    */
  19.     public static void main(String[] args) throws Exception {
  20.         ExecutorService es = new ThreadPoolExecutor(3,5,6,
  21.                 TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
  22.                 new ThreadPoolExecutor.AbortPolicy());
  25.         //直接把MyCallable对象扔进线程池里面 可以通过返回值 拿到对象
  26.         Future<String> f1 = es.submit(new MyCallable(100));
  27.         Future<String> f2 = es.submit(new MyCallable(200));
  28.         Future<String> f3 = es.submit(new MyCallable(300));
  29.         Future<String> f4 = es.submit(new MyCallable(400));
  30.         System.out.println(f1.get());
  31.         System.out.println(f2.get());
  32.         System.out.println(f3.get());
  33.         System.out.println(f4.get());
  35.     }
  37. }
  39. Callable:
  40. class MyCallable implements Callable<String> {
  41.     private  int n;
  43.     public MyCallable(int n) {
  44.         this.n = n;
  45.     }
  47.     /*重写call方法 线程任务方法*/
  48.     @Override
  49.     public String call() throws Exception {
  50.         int sum  = 0;
  51.         for (int i = 0; i <= n; i++) {
  52.             sum+=i;
  53.         }
  54.         return "子线程的结果是" +sum;
  55.     }
  56. }

可以直接把Callable放入线程池中

Executors工具类：
Executors的底层其实也是基于线程池的实现类ThreadPoolExecutors创建线程池对象

  1. Executors工具类底层是基于什么方式实现的线程池对象？
    1. 线程池ExecutorService的实现类：ThreadPoolExecutor
  2. Executors是否合适大型互联网场景的线程池方案？
    1. 不适合
    2. 建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确的运行规则，规避资源耗尽的风险。

定时器：

  • 定时器是一种控制任务延时调用，或者周期调用技术

定时器的实现方式

  • 方式一、Timer
    • 构造器：public Timer();//创建定时器对象
  • 方式二、ScheduuledExecutorService

Timer定时器的特点和存在的问题

  1. Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入
  2. 可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行

  3. 是单线程，出现异常程序就会死掉


    单线程定时器： ```java package com.h.h_timer;

import java.util.Timer; import java.util.TimerTask;

/使用定时器/

public class TimerDemo { public static void main(String[] args) { //创建定时器 Timer t = new Timer(); //调用方法处理定时任务 //每隔3秒触发一次，每隔两秒执行一次 //每隔3秒触发一次是这个任务的触发,每隔两秒是再次执行这个任务 t.schedule(new TimerTask() { @Override public void run() { //定时器本身就是一个线程 System.out.println(Thread.currentThread().getName()+”执行一次”);

  1.         }
  2.     },3000,2000);
  3.  }

}

  1. **ScheduledExecutorService**
  3. - 是为了弥补Timer的缺陷
  4. - Executors的方法：public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize);//得到线程池对象
  5. - ScheduleExecutorService的方法：public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimerUnit unit)
  7. **ScheduledExecutorService的优点    **
  9. 1. 基于线程池，某个任务的执行情况不会影响其他定时任务的执行
  11. 其他线程挂掉的时候别的线程不会挂掉<br />互不干扰
  13. 线程池定时器：
  14. ```java
  15. package com.h.h_timer;
  16. import java.util.Timer;
  17. import java.util.TimerTask;
  18. import java.util.concurrent.Executors;
  19. import java.util.concurrent.ScheduledExecutorService;
  20. import java.util.concurrent.ScheduledThreadPoolExecutor;
  21. import java.util.concurrent.TimeUnit;
  23. /*使用定时器*/
  25. public class TimerDemo2 {
  26.     public static void main(String[] args) {
  27.         //1、创建ScheduledExecutorService线程池，做定时器
  28.         //以后使用这种定时器进行开发
  29.         ScheduledExecutorService ses = Executors.newScheduledThreadPool(1);
  31.         //2、开启定时任务
  32.         //参数列表  1:定时器   2:触发时间    3:周期时间    4:单位 秒？毫秒？分？时？
  33.         ses.scheduleAtFixedRate(new TimerTask() {
  34.             @Override
  35.             public void run() {
  36.                 System.out.println("定时任务1");
  37.             }
  38.         },  0, 2, TimeUnit.SECONDS);
  40.      }
  41. }

并发与并行

  • 正在运行的程序(软件)就是一个，线程是属于进程的，多个线程其实是并发与并行同时进行

并发理解

  • CPU同时处理线程的数量有限
  • CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程是同时执行，这就是并发。
  • 并发：同一时间段，抢占CPU执行自己
  • 并行：同一时刻同时执行
    image.png

新的线程知识

如何让两个线程依次输出结果
例如:线程1 ABCDE 线程2: 12345
使用最新技术:
park是叫醒 unpark阻塞
LockSupport.park();与LockSupport.unpark();

notify()是按特定算法去叫醒某一个线程没法精确叫醒某一个线程
使用notifyAu()

  1. char aI = {1,2,3,4,5,6};
  2. char aI=C = {"a","b","c","d","e"};
  4. TransferQueue<Character> queue = new LinkedTransferQueue<~>();
  6. TransferQueue 相当于一个套筒 一个人把手伸进去 另一个也把手伸进去 一个人交出东西 另一个接收东西
  8. new Thread(() -> {
  9.     try{
  10.         for(char c : aI){
  12.             System.out.print(queue.take());
  13.             //传一个东西进行
  14.             queue.transfer(c);
  15.         }
  16.         }catch(InterruptedException e){
  17.             e.printStackTrace();
  18.         }
  19.     },"t1").start;
  21. new Thread(() ->{
  22.             try{
  23.         for(char c : aC){
  24.             //拿一个东西出来
  25.             queue.transfer(c);
  26.             System.out.print(queue.take());
  28.         }
  29.         }catch(InterruptedException e){
  30.             e.printStackTrace();
  31.         }
  32.     },"t2").start;
  34. })