多线程是java并发的基础，我们先来学习一下吧：

首先，让我们来起一个多线程，看看

  1. public class HelloWorld {
  2.     public static void main(String[] args) throws Exception {
  3.         // lambda 写法
  4.         Thread t = new Thread(() -> {
  5.             System.out.println("thread start");
  6.             try {
  7.                 Thread.sleep(100);  // 模拟IO操作，让线程等100毫秒
  8.             } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             } finally {
  11.                 System.out.println("thread end");
  12.             }
  13.         });
  14.         t.start();
  15.         System.out.println("main end");
  16.     }//thread start
  17.     // main end
  18.     // thread end  mianend与thread start 打印顺序并非一定的，这个是并发，不一定谁会先执行
  19. }

线程一般会存在几个状态，New 新建的线程对象，Runnable 正在运行中，Block 被阻塞，Waitting 等待中， Timeed Waittding 被sleep计时等待， Terminated 执行完毕

  1. public class HelloWorld {
  2.     public static void main(String[] args) throws Exception {
  3.         // lambda 写法
  4.         Thread t = new Thread(() -> {
  5.             System.out.println("thread start");
  6.             try {
  7.                 Thread.sleep(100);  // 模拟IO操作，让线程等100毫秒
  8.             } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             } finally {
  11.                 System.out.println("thread end");
  12.             }
  13.         });
  14.         System.out.println(t.getState());  // NEW 未执行线程
  15.         t.start();
  16.         System.out.println(t.getState());  // RUNNABLE 正在运行的线程
  17.         System.out.println("main end");
  18.         Thread.sleep(10);
  19.         System.out.println(t.getState());  // TIMED_WAITING  被sleep阻塞住的线程
  20.         Thread.sleep(100);
  21.         System.out.println(t.getState());  // TERMINATED  线程退出
  22.     }
  23. }

在学习python的时候我们知道一个线程可以等待另外一个线程，那java中也是一样的，都使用join

  1. public class HelloWorld {
  2.     public static void main(String[] args) throws Exception {
  3.         // lambda 写法
  4.         Thread t = new Thread(() -> {
  5.             System.out.println("thread start");
  6.             try {
  7.                 Thread.sleep(100);  // 模拟IO操作，让线程等100毫秒
  8.             } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             } finally {
  11.                 System.out.println("thread end");
  12.             }
  13.         });
  14.         t.start();
  15.         t.join();  // 等待 t 结束再往下走
  16.         System.out.println("main end");
  17.     }  // thread start
  18.     // thread end
  19.     // main end 这个main end会最终执行
  20. }

注意join中也是可以传参数的，传入的int值，意思是等待多少毫秒

进程如何中断呢，有两种方法

方法一

  1. class MyThread extends Thread{
  2.     @Override
  3.     public void run(){
  4.         // 判断进程是否被终端
  5.         while(! isInterrupted()){
  6.             System.out.println("i am alive");
  7.         }
  8.         System.out.println("end");
  9.     }
  10. }
  11. public class HelloWorld {
  12.     public static void main(String[] args) throws Exception {
  13.         // lambda 写法
  14.         Thread t = new MyThread();
  15.         t.start();
  16.         Thread.sleep(1000);
  17.         t.interrupt();  // 中断进程
  18.         System.out.println("main end");
  19.     }
  20. }

还有一种是设置标识位

当我们使用public时，线程间是可以访问变量的，java虚拟机是将变量保存在主内存上，当某一个线程访问变量时，会复制一份走，然后保存在自己的工作空间，如果发生改写，虚拟机会在某个时间之后将修改后的变量值改写主内存，但是这个时间是不确定的，因此我们需要使用volatile来声明这个变量，这样就会做到下述两点：

  • 每次访问变量，都会去主内存中取复制一份
  • 每次修改变量，会立即写会主内存
  1. class MyThread extends Thread {
  2.     public volatile boolean isExit = false;
  4.     @Override
  5.     public void run() {
  6.         // 判断标志位
  7.         while (!this.isExit) {
  8.             System.out.println("i am alive");
  9.         }
  10.         System.out.println("end");
  11.     }
  12. }
  14. public class HelloWorld {
  15.     public static void main(String[] args) throws Exception {
  16.         // lambda 写法
  17.         MyThread t = new MyThread();
  18.         t.start();
  19.         Thread.sleep(1);
  20.         t.isExit = true;  // 中断进程
  21.         System.out.println("main end");
  22.     }
  23. }

我们在使用的如果不设置volatile中断时间感觉也很快，这个是因为JVM的回写主内存非常快，所以不要爆侥幸信息，一定要记得声明volatile

接下来看一下守护线程，守护线程就是当所有非守护线程结束时，他也会结束，我记得在pyton中又叫做傀儡线程，设置守护需要在启动线程之前。

  1. class MyThread extends Thread {
  2.     @Override
  3.     public void run() {
  4.         // 判断进程是否被终端
  5.         try {
  6.             Thread.sleep(1000000);
  7.             // 当线程被推出时 会抛出 InterruptedException 这个错误
  8.         } catch (InterruptedException e) {
  9.             e.printStackTrace();
  10.         }
  11.         System.out.println("end");
  12.     }
  13. }
  15. public class HelloWorld {
  16.     public static void main(String[] args) throws Exception {
  17.         // lambda 写法
  18.         MyThread t = new MyThread();
  19.         t.setDaemon(true);
  20.         t.start();
  21.         Thread.sleep(10);
  22.         System.out.println("main end");
  23.     }
  24. }

t这个线程是主线程的守护线程，会在主线程退出时退出。

说了这个，那么多线程对于修改数据，是不是安全的呢？我们来看一个例子

  1. class Num{
  2.     public static int num = 0;
  3. }
  4. class AddThread extends Thread {
  5.     @Override
  6.     public void run() {
  7.         int i = 0;
  8.         for(;i<100000;i++){
  9.             Num.num += 1;
  10.         }
  11.         System.out.println("AddThread end");
  12.     }
  13. }
  14. class DecThread extends Thread{
  15.     @Override
  16.     public void run(){
  17.         int i = 0;
  18.         for(;i<100000;i++){
  19.             Num.num -=1;
  20.         }
  21.         System.out.println("DecThread end");
  22.     }
  23. }
  25. public class HelloWorld {
  26.     public static void main(String[] args) throws Exception {
  27.         // lambda 写法
  28.         Thread t = new AddThread();
  29.         Thread t1 = new DecThread();
  30.         System.out.println(Num.num);  // 0
  31.         t.start();
  32.         t1.start();
  33.         t.join();
  34.         t1.join();
  35.         System.out.println(Num.num);  // -803
  36.     }
  37. }

这个结果并非我们预期的0，因此需要咋办，这个是因为所有的线程调度都是由操作系统做的，如果add正在主内存中取值就被挂起，然后dec去主内存中取值并作减法，然后退回给主系统，之后add才调用，这个时候就会造成数据混乱，那么怎么办呢？加锁，也就是说，某个线程在操作数据时，另外一个线程是不能去碰这个数据

  1. class Num {
  2.     public static int num = 0;
  3.     public static final Object lock = new Object();
  4. }
  6. class AddThread extends Thread {
  7.     @Override
  8.     public void run() {
  9.         int i = 0;
  10.         for (; i < 100000; i++) {
  11.             // synchronized 这个就锁住了Num.lock
  12.             synchronized (Num.lock) {
  13.                 Num.num += 1;
  14.             }// 释放锁
  15.         }
  16.         System.out.println("AddThread end");
  17.     }
  18. }
  20. class DecThread extends Thread {
  21.     @Override
  22.     public void run() {
  23.         int i = 0;
  24.         for (; i < 100000; i++) {
  25.             synchronized (Num.lock) {
  26.                 Num.num -= 1;
  27.             }
  28.         }
  29.         System.out.println("DecThread end");
  30.     }
  31. }
  33. public class HelloWorld {
  34.     public static void main(String[] args) throws Exception {
  35.         // lambda 写法
  36.         Thread t = new AddThread();
  37.         Thread t1 = new DecThread();
  38.         System.out.println(Num.num);  // 0
  39.         t.start();
  40.         t1.start();
  41.         t.join();
  42.         t1.join();
  43.         System.out.println(Num.num);  // 0
  44.     }
  45. }

另外对于一些复制操作（基础类型除了long，double，还有引用类型）是原子操作，不需要加锁

我们来看一下如何进行加锁

  1. class Num {
  2.     public static int num = 0;
  3.     public static final Object lock = new Object();
  4.     private int nn = 0;
  6.     // 同步方法，这条语句相当于 synchronized(this){this.nn += 1;} 就是把整个实例都锁住了
  7.     public synchronized void add() {
  8.         this.nn += 1;
  9.     }
  11.     public synchronized void dec() {
  12.         this.nn -= 1;
  13.     }
  15.     public void printNn() {
  16.         System.out.println(this.nn);
  17.     }
  18. }
  20. class AddThread extends Thread {
  21.     private Num n = null;
  23.     public AddThread(Num n) {
  24.         super();
  25.         this.n = n;
  26.     }
  28.     @Override
  29.     public void run() {
  30.         int i = 0;
  31.         for (; i < 100000; i++) {
  32.             // synchronized 这个就锁住了Num.lock
  33.             synchronized (Num.lock) {
  34.                 Num.num += 1;
  35.             }// 释放锁
  36.             this.n.add();
  37.         }
  38.         System.out.println("AddThread end");
  39.     }
  40. }
  42. class DecThread extends Thread {
  43.     private Num n = null;
  45.     public DecThread(Num n) {
  46.         super();
  47.         this.n = n;
  48.     }
  50.     @Override
  51.     public void run() {
  52.         int i = 0;
  53.         for (; i < 100000; i++) {
  54.             synchronized (Num.lock) {
  55.                 Num.num -= 1;
  56.             }
  57.             this.n.dec();
  58.         }
  59.         System.out.println("DecThread end");
  60.     }
  61. }
  63. public class HelloWorld {
  64.     public static void main(String[] args) throws Exception {
  65.         Num n = new Num();
  66.         // lambda 写法
  67.         Thread t = new AddThread(n);
  68.         Thread t1 = new DecThread(n);
  69.         System.out.println(Num.num);  // 0
  70.         t.start();
  71.         t1.start();
  72.         t.join();
  73.         t1.join();
  74.         System.out.println(Num.num);  // 0
  75.         n.printNn();  // 0
  76.     }
  77. }

java中的锁是可重入锁，什么意思，就是可以重复获取，获取一次锁计数+1，释放一次锁计数-1，最终释放完毕所有锁就归零

因此如果我们将锁住的信息定义为final标识符，那么他就不能重复获取锁，这样一旦锁的顺序不对，就会产生死锁，如下面的例子

  1. class Num {
  2.     public static int num = 0;
  3.     public static final Object lock = new Object();
  4.     public static final Object lock2 = new Object();
  6. }
  8. class AddThread extends Thread {
  10.     @Override
  11.     public void run() {
  12.         int i = 0;
  13.         for (; i < 100000; i++) {
  14.             // synchronized 这个就锁住了Num.lock
  15.             synchronized (Num.lock2) {
  16.                 Num.num += 1;
  17.                 synchronized (Num.lock) {
  18.                     Num.num -= 1;
  19.                 }
  20.             }// 释放锁
  21.         }
  22.         System.out.println("AddThread end");
  23.     }
  24. }
  26. class DecThread extends Thread {
  28.     @Override
  29.     public void run() {
  30.         int i = 0;
  31.         for (; i < 100000; i++) {
  32.             synchronized (Num.lock) {
  33.                 Num.num -= 1;
  34.                 synchronized (Num.lock2) {
  35.                     Num.num += 1;
  36.                 }
  37.             }
  38.         }
  39.         System.out.println("DecThread end");
  40.     }
  41. }
  43. public class HelloWorld {
  44.     public static void main(String[] args) throws Exception {
  45.         Thread t = new AddThread();
  46.         Thread t1 = new DecThread();
  47.         System.out.println(Num.num);  // 0
  48.         t.start();
  49.         t1.start();
  50.         t.join();
  51.         t1.join();
  52.         System.out.println(Num.num);  // 0
  53.     }
  54. }

t线程先锁住lock然后在去锁住lock2，t1线程先锁住lock2然后在去锁住lock，因为lock都是不可变的，有final标识符，这样t跟t1就产生了冲突，谁也无法获取对方的未释放的锁，产生了死锁，程序进入等待，因此一定要注意加锁的顺序

那么接下来我们需要思考对于队列来讲，如何进行多线程协同呢，也就是一些放任务，一些取任务，我们可能想到取任务时使用poll，但是我们要求必须取到任务，

  1. import java.util.ArrayList;
  2. import java.util.LinkedList;
  3. import java.util.List;
  4. import java.util.Queue;
  6. class Task {
  7.     Queue<String> q = new LinkedList<>();
  9.     public synchronized void add(String s) {
  10.         q.add(s);
  11.     }
  13.     public synchronized String get() throws InterruptedException {
  14.         while (q.isEmpty()) {
  15.             System.out.println("wait me");
  17.         }
  18.         return q.remove();
  19.     }
  20. }
  22. public class HelloWorld {
  23.     public static void main(String[] args) throws Exception {
  24.         Task t = new Task();
  25.         List<Thread> tt = new ArrayList<>();
  26.         for (int i = 0; i < 10; i++) {
  27.             Thread ts = new Thread(() -> {
  28.                 while (true) {
  29.                     String s = null;
  30.                     try {
  31.                         s = t.get();
  32.                     } catch (InterruptedException e) {
  33.                         e.printStackTrace();
  34.                     }
  35.                     System.out.println(s);
  36.                 }
  37.             });
  38.             ts.start();
  39.             tt.add(ts);
  40.         }
  41.         Thread add = new Thread() {
  42.             @Override
  43.             public void run() {
  44.                 while (true) {
  45.                     for (int i = 0; i < 100; i++) {
  46.                         t.add("task" + i);
  47.                         try {
  48.                             Thread.sleep(10);
  49.                         } catch (InterruptedException e) {
  50.                             e.printStackTrace();
  51.                         }
  52.                     }
  53.                 }
  54.             }
  55.         };
  56.         add.start();
  57.     }
  58. }

我看上述代码，这个就是我们之前看的加锁，但是看输出结果确实无限的wait me，这是因为在获取任务时，因为为空就会陷入while的无限循环中，这个这个方法锁住的是this，这个实例，add也就无法进行添加任务，形成了死循环，那么这个就需要wait跟notifyall这两个方法，他们必须在synchorized中使用，wait就是释放当前锁，并休眠，notifyall就是通知所有休眠的进行起来抢锁并执行，上述代码修改为下面这样

  1. import java.util.ArrayList;
  2. import java.util.LinkedList;
  3. import java.util.List;
  4. import java.util.Queue;
  6. class Task {
  7.     Queue<String> q = new LinkedList<>();
  9.     public synchronized void add(String s) {
  10.         q.add(s);
  11.         this.notifyAll();
  12.     }
  14.     public synchronized String get() throws InterruptedException {
  15.         while (q.isEmpty()) {
  16.             this.wait();
  17.             System.out.println("wait me");
  19.         }
  20.         return q.remove();
  21.     }
  22. }
  24. public class HelloWorld {
  25.     public static void main(String[] args) throws Exception {
  26.         Task t = new Task();
  27.         List<Thread> tt = new ArrayList<>();
  28.         for (int i = 0; i < 10; i++) {
  29.             Thread ts = new Thread(() -> {
  30.                 while (true) {
  31.                     String s = null;
  32.                     try {
  33.                         s = t.get();
  34.                     } catch (InterruptedException e) {
  35.                         e.printStackTrace();
  36.                     }
  37.                     System.out.println(s);
  38.                 }
  39.             });
  40.             ts.start();
  41.             tt.add(ts);
  42.         }
  43.         Thread add = new Thread() {
  44.             @Override
  45.             public void run() {
  46.                 while (true) {
  47.                     for (int i = 0; i < 100; i++) {
  48.                         t.add("task" + i);
  49.                         try {
  50.                             Thread.sleep(10);
  51.                         } catch (InterruptedException e) {
  52.                             e.printStackTrace();
  53.                         }
  54.                     }
  55.                 }
  56.             }
  57.         };
  58.         add.start();
  59.     }
  60. }

增加两行代码，就实现了我们的功能。

synchronized锁在锁比较多的情况下容易造成死锁，而且在想要获取锁的时候必须等待，没有任何尝试机制，接下来我们看一下另外一种锁的ReentrantLock

  1. import java.util.ArrayList;
  2. import java.util.LinkedList;
  3. import java.util.List;
  4. import java.util.Queue;
  5. import java.util.concurrent.TimeUnit;
  6. import java.util.concurrent.locks.Condition;
  7. import java.util.concurrent.locks.Lock;
  8. import java.util.concurrent.locks.ReentrantLock;
  10. class Task {
  11.     Queue<String> q = new LinkedList<>();
  12.     private final Lock lock = new ReentrantLock();  // 实例化锁
  13.     private final Condition condition = lock.newCondition();  // 通过该锁，实例化一个与之匹配的condition
  14.  
  15.     public void add(String s) throws InterruptedException {
  16.         // 这个就是尝试获取锁，如果1s获取不到就不再等待，跳过这里面的代码块
  17.         if (lock.tryLock(1, TimeUnit.SECONDS)) {
  18.             try {
  19.                 q.add(s);
  20.                 condition.signalAll();  // 等同于notifyall
  21.             } finally {
  22.                 lock.unlock();
  23.             }
  24.         }
  26.     }
  28.     public String get() throws InterruptedException {
  29.         // 普通的锁，会等待
  30.         lock.lock();
  31.         try {
  32.             while (q.isEmpty()) {
  33.                 condition.await();  // 等同于wait
  34.             }
  35.             return q.remove();
  36.         } finally {
  37.             lock.unlock();
  38.         }
  39.     }
  40. }
  42. public class HelloWorld {
  43.     public static void main(String[] args) throws Exception {
  44.         Task t = new Task();
  45.         List<Thread> tt = new ArrayList<>();
  46.         for (int i = 0; i < 10; i++) {
  47.             Thread ts = new Thread(() -> {
  48.                 while (true) {
  49.                     String s = null;
  50.                     try {
  51.                         s = t.get();
  52.                     } catch (InterruptedException e) {
  53.                         e.printStackTrace();
  54.                     }
  55.                     System.out.println(s);
  56.                 }
  57.             });
  58.             ts.start();
  59.             tt.add(ts);
  60.         }
  61.         Thread add = new Thread() {
  62.             @Override
  63.             public void run() {
  64.                 while (true) {
  65.                     for (int i = 0; i < 100; i++) {
  66.                         try {
  67.                             t.add("task" + i);
  68.                         } catch (InterruptedException e) {
  69.                             e.printStackTrace();
  70.                         }
  71.                         try {
  72.                             Thread.sleep(10);
  73.                         } catch (InterruptedException e) {
  74.                             e.printStackTrace();
  75.                         }
  76.                     }
  77.                 }
  78.             }
  79.         };
  80.         add.start();
  81.     }
  82. }

加下来看一下读写锁，上面的例子其实所有的读操作也会被锁，但对于读操作来讲，不影响我们的数据，我们希望在进行写的时候锁住，不写的时候，读没有限制，因此可以使用读写锁

  1. import java.util.*;
  2. import java.util.concurrent.locks.*;
  4. class Task {
  5.     Queue<String> q = new LinkedList<>();
  6.     private final ReadWriteLock lock = new ReentrantReadWriteLock();  // 实例化读写锁
  7.     private final Lock rlock = lock.readLock();  // 实例化读锁
  8.     private final Lock wlock = lock.writeLock(); // 实例化写锁
  9.     private int[] n = new int[100];
  11.     public void add(int i) throws InterruptedException {
  12.         // 写入锁
  13.         wlock.lock();
  14.         try {
  15.             n[i] += 1;
  16.         } finally {
  17.             wlock.unlock();
  18.         }
  20.     }
  22.     public int[] get() throws InterruptedException {
  23.         // 读锁
  24.         rlock.lock();
  25.         try {
  27.             return Arrays.copyOf(n, n.length);
  28.         } finally {
  29.             rlock.unlock();
  30.         }
  31.     }
  32. }
  34. public class HelloWorld {
  35.     public static void main(String[] args) throws Exception {
  36.         Task t = new Task();
  37.         List<Thread> tt = new ArrayList<>();
  38.         for (int i = 0; i < 10; i++) {
  39.             Thread ts = new Thread(() -> {
  40.                 while (true) {
  41.                     int[] s = null;
  42.                     try {
  43.                         s = t.get();
  44.                     } catch (InterruptedException e) {
  45.                         e.printStackTrace();
  46.                     }
  47.                     System.out.println(s);
  48.                 }
  49.             });
  50.             ts.start();
  51.             tt.add(ts);
  52.         }
  53.         Thread add = new Thread() {
  54.             @Override
  55.             public void run() {
  56.                 while (true) {
  57.                     for (int i = 0; i < 100; i++) {
  58.                         try {
  59.                             t.add(i);
  60.                         } catch (InterruptedException e) {
  61.                             e.printStackTrace();
  62.                         }
  63.                         try {
  64.                             Thread.sleep(10);
  65.                         } catch (InterruptedException e) {
  66.                             e.printStackTrace();
  67.                         }
  68.                     }
  69.                 }
  70.             }
  71.         };
  72.         add.start();
  73.     }
  74. }

上面的读写锁是一种悲观锁，比如说，如果换成队列，也就是说，写的时候，读锁必须全部释放完毕，否则无法进行下一步操作，可以使用之前队列的例子试试，下面看一下乐观锁

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.concurrent.locks.*;
  5. class Task {
  6.     private final StampedLock lock = new StampedLock();  // 实例化锁
  7.     private Double s = 0.00;
  9.     public void add(Double d) {
  10.         // 写入锁
  11.         long stamp = lock.writeLock();
  12.         try {
  13.             s += d;
  14.         } finally {
  15.             lock.unlockWrite(stamp);
  16.         }
  17.     }
  19.     public Double get() {
  20.         // 获取乐观锁
  21.         long stamp = lock.tryOptimisticRead();
  22.         Double d = s;  // double 赋值非原子级操作
  23.         System.out.println("du");
  24.         // 检查当前所是否是最新的
  25.         if (!lock.validate(stamp)) {
  26.             System.out.println("not new");
  27.             // 如果不是则获取悲观锁
  28.             stamp = lock.readLock();
  29.             try {
  30.                 d = s;
  31.             } finally {
  32.                 lock.unlockRead(stamp);
  33.             }
  34.         }
  35.         return d;
  36.     }
  37. }
  39. public class HelloWorld {
  40.     public static void main(String[] args) throws Exception {
  41.         Task t = new Task();
  42.         List<Thread> tt = new ArrayList<>();
  43.         for (int i = 0; i < 10; i++) {
  44.             Thread ts = new Thread(() -> {
  45.                 while (true) {
  46.                     Double s;
  47.                     s = t.get();
  48.                     System.out.println(s);
  49.                 }
  50.             });
  51.             ts.start();
  52.             tt.add(ts);
  53.         }
  54.         Thread add = new Thread() {
  55.             @Override
  56.             public void run() {
  57.                 while (true) {
  58.                     for (int i = 0; i < 100; i++) {
  59.                         t.add(1.0000001);
  60.                         try {
  61.                             Thread.sleep(10000);
  62.                         } catch (InterruptedException e) {
  63.                             e.printStackTrace();
  64.                         }
  65.                     }
  66.                 }
  67.             }
  68.         };
  69.         add.start();
  70.     }
  71. }

说完线程，那接下来我们看一下线程池

  1. import java.util.ArrayList;
  2. import java.util.concurrent.*;
  4. class Task implements Callable<String> {
  5.     public String call() throws Exception {
  6.         Thread.sleep(10000);
  7.         return "mmm";
  8.     }
  9. }
  11. class Task1 implements Runnable {
  12.     private int i;
  14.     public Task1(int d) {
  15.         this.i = d;
  16.     }
  18.     public void run() {
  19.         try {
  20.             Thread.sleep(1000);
  21.         } catch (InterruptedException e) {
  22.             e.printStackTrace();
  23.         }
  24.         System.out.println("end" + this.i);
  25.     }
  26. }
  28. class MyThread extends Thread {
  29.     private Future<String> f;
  31.     public MyThread(Future<String> f) {
  32.         super();
  33.         this.f = f;
  34.     }
  36.     @Override
  37.     public void run() {
  38.         try {
  39.             System.out.println(f.get());
  40.         } catch (InterruptedException e) {
  41.             e.printStackTrace();
  42.         } catch (ExecutionException e) {
  43.             e.printStackTrace();
  44.         }
  45.     }
  46. }
  48. public class HelloWorld {
  49.     public static void main(String[] args) throws Exception {
  50.         ExecutorService es = Executors.newFixedThreadPool(4);  // 固定大小的线程池
  51.         // <T> Future<T> submit(Callable<T> task); 这个方法是往线程池中塞任务，看到接受的是Callable类型，返回的是Future类型，那就按这个借口来定义
  53.         Future<String> f = es.submit(new Task());  // 获取一个未来产生的Future对象
  54.         try {
  55.             String m = f.get(1, TimeUnit.SECONDS);  // 获取结果只等待指定时间，如果没有等到，会报出下面的错误
  56.             System.out.println(m);
  57.         } catch (Exception e) {
  58.             System.out.println(e);  // java.util.concurrent.TimeoutException
  59.         } finally {
  60.             System.out.println("not recv");
  61.         }
  62.         System.out.println(f.isDone());  // 判断是否完成
  63.         System.out.println(f.get());  // 等待获取结果，会一直阻塞
  64.         es.shutdown();  // 关闭线程池
  66.         ExecutorService es1 = Executors.newCachedThreadPool();  // 动态变化的线程池
  68.         var f1 = new ArrayList<Future<String>>();
  69.         for (int i = 0; i < 10; i++) {
  70.             Future<String> ff = es1.submit(new Task());  // 在这里尽量不要用定值的线程池，如果超出线程池大小，会报错
  71.             f1.add(ff);
  72.         }  // 十个 mmm 同时打印
  73.         for (Future<String> ffff : f1) {
  74.             var mt = new MyThread(ffff);
  75.             mt.start();
  76.             mt.join();
  77.         }
  78.         Thread.sleep(10100);  // 记得晚点关闭线程池
  79.         es1.shutdown();
  80.         ExecutorService es2 = Executors.newFixedThreadPool(2);  // 固定大小的线程池
  81.         for (int i = 0; i < 6; i++) {
  82.             es2.submit(new Task1(i));
  83.         }  // 两个两个的打印
  84.         Thread.sleep(10000);
  85.         es2.shutdown();
  87.         // 定时反复执行任务的线程池
  88.         ScheduledExecutorService es3 = Executors.newScheduledThreadPool(4);
  89.         es3.schedule(new Task1(1), 4, TimeUnit.SECONDS);  // 4 s后执行这个任务
  90.         es3.scheduleAtFixedRate(new Task1(2), 2, 1, TimeUnit.SECONDS);  // 两秒后，每隔1秒执行一次任务
  91.         es3.scheduleWithFixedDelay(new Task1(3), 2, 1, TimeUnit.SECONDS);  // 两秒后，上一次任务结束，隔1秒执行一次任务
  92.         Thread.sleep(10000);
  93.         es3.shutdown();
  95.     }
  96. }

使用feature总是得用get等待，或者轮询看看是否isDone，来看一下自动调用回掉对象

  1. import java.util.concurrent.*;
  3. public class HelloWorld {
  4.     public static void main(String[] args) throws Exception {
  5.         // 这个是串行
  6.         CompletableFuture<String> f = CompletableFuture.supplyAsync(HelloWorld::call);  // 第一个任务
  7.         // 上面任务完成后执行这个任务，s是上一个的返回值
  8.         CompletableFuture<String> f1 = f.thenApplyAsync((s) -> {
  9.             System.out.println(s);  // mmm
  10.             return HelloWorld.call();
  11.         });
  12.         // f1成功之后打印
  13.         f1.thenAccept((res) -> {
  14.             System.out.println(res);  // mmm
  15.         });
  16.         // f1失败打印
  17.         f1.exceptionally(e -> {
  18.             e.printStackTrace();
  19.             return null;
  20.         });
  21.         Thread.sleep(4000);
  22.         System.out.println("开始并行");
  23.         // 接下来看一下并行的
  24.         CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> {
  25.             return call1(2);
  26.         });
  27.         CompletableFuture<String> f3 = CompletableFuture.supplyAsync(() -> {
  28.             return call1(3);
  29.         });
  30.         CompletableFuture<String> f4 = CompletableFuture.supplyAsync(() -> {
  31.             return call1(4);
  32.         });
  33.         CompletableFuture<String> f5 = CompletableFuture.supplyAsync(() -> {
  34.             return call1(5);
  35.         });
  36.         CompletableFuture<Object> ff = CompletableFuture.anyOf(f2, f3, f4, f5);
  37.         f2.thenAccept(System.out::println);
  38.         f3.thenAccept(System.out::println);
  39.         f4.thenAccept(System.out::println);
  40.         f5.thenAccept(System.out::println);
  41.         ff.thenAccept(System.out::println);  // 感觉默认的线程应该是3个，因为第四个总感觉执行的慢一点，ff就是谁的快接受那个线程
  43.         Thread.sleep(4000);
  45.     }
  47.     static String call() {
  48.         try {
  49.             Thread.sleep(2000);
  50.         } catch (InterruptedException e) {
  51.             e.printStackTrace();
  52.         }
  53.         return "mmm";
  54.     }
  56.     static String call1(int n) {
  57.         try {
  58.             Thread.sleep(2000);
  59.         } catch (InterruptedException e) {
  60.             e.printStackTrace();
  61.         }
  62.         return "mmm" + n;
  63.     }
  64. }

版权声明：本文为yangshixiong原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/yangshixiong/p/12177601.html