程序？进程？线程

线程

个数设置

线程个数：N= N U （1 + wait time / compute time）

状态

create

runnable

runnig

blocking / waiting

terminate

interrupt

interrupt

设置标记位

isInterrupt

查询是否可以被打断

interrupted

查询+重置标记位
wait sleep join一起使用会报错：interruptException
synchronized lock等获取锁的线程一起使用不会（ReentryLock可以使用LockInterruptly打断）

停止

自然结束

stop

执行后直接停止线程，不管线程在干嘛，如果恰巧在进行共享变量的属性赋值，则直接中断该过程

suspend/resume

如果线程正持有一把锁，则直接停止线程，不释放锁（类似于stop），容易造成死锁

volatile属性

不依赖于某个状态值时

interrupt

启动方式

  1. Thread
  2. Runnable
  3. lambda
  4. 线程池
  5. callable

并发三大特性

可见性（主存 & 本地内存）

解决方法

volatile

  • 修饰引用类型：只是引用本身可见，但是引用内部的数据不可见

    synchronized

    缓存行64bit（常见用long变量填充）

    cache line padding | @Contended + -XX:-RestrictContented

    why

    结果多次实践获得

  • 太大：内存命中率低，读取慢

  • 太小：读取次数多，性能低

    MESI（缓存一致性协议intel x86）

  1. modified
  2. Exclusive
  3. Shared
  4. Invalid

    有序性

    as-if-serial

    在单线程中，如果不影响查询最后的一致性那么cpu就会对程序进行一定的重排序

    原子性

    increment

    synchronized

    atomic

    自旋

    longaddr

    分段锁

    锁

    synchronized（blocked）=>系统锁=>执行时间长，线程数多

    支持可重入锁，当发生异常的时候会自动释放锁

    可重入锁：一个对象获得某种类型的锁后（还在使用）还可以获得该类锁

  1. package multiThreading;
  3. import java.util.concurrent.TimeUnit;
  5. /**
  6.  * Created by Intellij IDEA.
  7.  *
  8.  * @author JonnyJiang
  9.  * @date 2021/8/4
  10.  */
  11. public class SynchronizedState {
  12.     public static void main(String[] args) throws InterruptedException {
  13.         SynchronizedState synchronizedState = new SynchronizedState();
  14.         Thread thread1 = new Thread(()-> {
  15.             try {
  16.                 synchronizedState.m1();
  17.             } catch (InterruptedException e) {
  18.                 e.printStackTrace();
  19.             }
  20.         });
  21.         Thread thread2 = new Thread(()-> {
  22.             try {
  23.                 synchronizedState.m2();
  24.             } catch (InterruptedException e) {
  25.                 e.printStackTrace();
  26.             }
  27.         });
  29.         thread1.start();
  30.         TimeUnit.SECONDS.sleep(1);
  31.         thread2.start();
  32.         TimeUnit.SECONDS.sleep(1);
  33.         System.out.println(thread2.getState());
  34.     }
  36.     public synchronized void m1() throws InterruptedException {
  37.         System.out.println(Thread.currentThread().getState());
  38.         TimeUnit.SECONDS.sleep(10);
  39.     }
  41.     public synchronized void m2() throws InterruptedException {
  42.         System.out.println(Thread.currentThread().getState());
  43.         TimeUnit.SECONDS.sleep(10);
  44.     }
  45. }

lock（自旋=>waiting）=>用户锁=>执行时间短，线程数少

  1. package multiThreading;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. /**
  8.  * Created by Intellij IDEA.
  9.  *
  10.  * @author JonnyJiang
  11.  * @date 2021/8/4
  12.  */
  13. public class LockState {
  15.     public static void main(String[] args) throws InterruptedException {
  16.         Lock lock = new ReentrantLock();
  18.         Thread thread1 = new Thread(()->{
  19.             try{
  20.                 lock.lock();
  21.                 for (;;){
  23.                 }
  24.             }catch (Exception e){
  26.             }finally {
  27.                 lock.unlock();
  28.             }
  29.         });
  31.         Thread thread2 = new Thread(()->{
  32.             try{
  33.                 lock.lock();
  34.                 for(;;){
  36.                 }
  37.             }catch (Exception e){
  39.             }finally {
  41.             }
  42.         });
  44.         thread1.start();
  45.         TimeUnit.SECONDS.sleep(1);
  46.         thread2.start();
  47.         TimeUnit.SECONDS.sleep(1);
  48.         System.out.println(thread2.getState());
  49.     }
  51. }

ReentryLock

CountDownLatch（类似于批处理的thead.join()，只可以使用一次）

  1. package multiThreading;
  3. import java.util.concurrent.CountDownLatch;
  5. /**
  6.  * Created by Intellij IDEA.
  7.  *
  8.  * @author JonnyJiang
  9.  * @date 2021/8/3
  10.  */
  11. public class CountDownLatchDemo {
  12.     public static void main(String[] args) {
  13.         CountDownLatch countDownLatch = new CountDownLatch(100);
  14.         Thread[] threads = new Thread[100];
  15.         for (int i = 0; i < threads.length; i++) {
  16.             threads[i] = new Thread(()->{
  17.                 System.out.println(Thread.currentThread().getName());
  18.                 countDownLatch.countDown();
  19.             });
  20.         }
  22.         for(Thread t:threads){
  23.             t.start();
  24.         }
  26.         try{
  27.             countDownLatch.await();
  28.         }catch (Exception e){
  29.             e.printStackTrace();
  30.         }finally {
  31.             System.out.println("end latch");
  32.         }
  33.     }
  34. }

CyclicBarrier（等指定数量的线程执行完了后才放行，可以使用多次，多批次）

  1. package multiThreading;
  3. import java.util.concurrent.BrokenBarrierException;
  4. import java.util.concurrent.CyclicBarrier;
  6. /**
  7.  * Created by Intellij IDEA.
  8.  *
  9.  * @author JonnyJiang
  10.  * @date 2021/8/3
  11.  */
  12. public class CyclicBarrierDemo {
  13.     public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
  14.         // 每次等待20个线程
  15.         CyclicBarrier cyclicBarrier = new CyclicBarrier(20,()->{
  16.             System.out.println("go go go");
  17.         });
  19.         Thread[] threads = new Thread[100];
  20.         for (int i = 0; i < threads.length; i++) {
  21.             threads[i] = new Thread(()->{
  22.                 try {
  23.                     cyclicBarrier.await();
  24.                 } catch (InterruptedException e) {
  25.                     e.printStackTrace();
  26.                 } catch (BrokenBarrierException e) {
  27.                     e.printStackTrace();
  28.                 }
  29.             });
  30.         }
  32.         for(Thread t:threads){
  33.             t.start();
  34.         }
  36.         System.out.println("end");
  37.     }
  38. }

phaser（跟cyclicbarrier很相似，只不过是可以具体的分不同的阶段，以及可以很方便的增加一些筛选条件）

  1. package multiThreading;
  3. import java.util.concurrent.*;
  5. /**
  6.  * Created by Intellij IDEA.
  7.  *
  8.  * @author JonnyJiang
  9.  * @date 2021/8/4
  10.  */
  11. public class PhaserDemo {
  12.     public static void main(String[] args) {
  13.         MyPhaser myPhaser = new MyPhaser();
  14.         Thread[] threads = new Thread[]{new Thread(new Person(myPhaser,"张三"),"张三"), new Thread(new Person(myPhaser,"李四"),"李四"),new Thread(new Person(myPhaser,"王五"),"王五")};
  15.         for (Thread t:threads){
  16.             t.start();
  17.         }
  20.     }
  21. }
  23. class MyPhaser extends Phaser {
  25.     @Override
  26.     protected boolean onAdvance(int phase, int registeredParties) {
  27.         switch (phase){
  28.             case 0:
  29.                 System.out.println("walk"+registeredParties);
  30.                 return false;
  31.             case 1:
  32.                 System.out.println("go"+registeredParties);
  33.                 return false;
  34.             case 2:
  35.                 System.out.println("stop"+registeredParties);
  36.                 return false;
  37.             default:
  38.                 System.out.println("end");
  39.                 return true;
  40.         }
  41.     }
  42. }
  44. class Person implements Runnable{
  45.     private MyPhaser myPhaser = null;
  46.     private String name = null;
  48.     public Person(MyPhaser myPhaser, String name){
  49.         this.myPhaser = myPhaser;
  50.         this.myPhaser.register();
  51.         this.name = name;
  52.     }
  54.     @Override
  55.     public void run() {
  56.         walk();
  57.         go();
  58.         stop();
  59.     }
  61.     public void walk(){
  62.         System.out.println("走："+Thread.currentThread().getName());
  63.         this.myPhaser.arriveAndAwaitAdvance();
  64.     }
  66.     public void go(){
  67.         System.out.println("跑："+Thread.currentThread().getName());
  68.         this.myPhaser.arriveAndAwaitAdvance();
  69.     }
  71.     public void stop(){
  72.         if(!this.name.equals("张三")){
  73.             this.myPhaser.arriveAndAwaitAdvance();
  74.         }
  75.         System.out.println("停止了"+Thread.currentThread().getName());
  76.     }
  77. }

ReentrantReadWriteLock

  1. package multiThreading;
  3. import java.time.LocalDate;
  4. import java.util.Random;
  5. import java.util.concurrent.TimeUnit;
  6. import java.util.concurrent.locks.Lock;
  7. import java.util.concurrent.locks.ReentrantLock;
  8. import java.util.concurrent.locks.ReentrantReadWriteLock;
  10. /**
  11.  * Created by Intellij IDEA.
  12.  *
  13.  * @author JonnyJiang
  14.  * @date 2021/8/5
  15.  */
  16. public class ReadWriteLockDemo {
  18.     private static int value = 0;
  19.     public static void main(String[] args) {
  20.         Lock reentrantLockW = new ReentrantLock();
  21.         Lock reentrantLockR = new ReentrantLock();
  22.         ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
  23.         ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
  24.         ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
  26.         Runnable readR = ()->read(readLock);
  27.         Runnable readW = ()->write(writeLock, new Random().nextInt(100));
  29.         for(int i = 0;i<10;i++){
  30.             new Thread(readR).start();
  31.         }
  32.         for (int i = 0; i < 2; i++) {
  33.             new Thread(readW).start();
  34.         }
  36.     }
  38.     public static void read(Lock lock){
  39.         try{
  40.             lock.lock();
  41.             System.out.println("read over\t"+value);
  42.             Thread.sleep(1000);
  43.         }catch (Exception e){
  44.             e.printStackTrace();
  45.         }finally {
  46.             lock.unlock();
  47.         }
  48.     }
  50.     public static void write(Lock lock,int newValue){
  51.         try{
  52.             lock.lock();
  53.             value = newValue;
  54.             System.out.println("write over");
  55.             Thread.sleep(1000);
  56.         }catch (Exception e){
  57.             e.printStackTrace();
  58.         }finally {
  59.             lock.unlock();
  60.         }
  61.     }
  62. }

LockSupport（可以自定义阻塞锁（waiting））

  1. package multiThreading;
  3. import java.sql.Timestamp;
  4. import java.util.concurrent.TimeUnit;
  5. import java.util.concurrent.locks.LockSupport;
  7. /**
  8.  * Created by Intellij IDEA.
  9.  *
  10.  * @author JonnyJiang
  11.  * @date 2021/8/5
  12.  */
  13. public class LockSupportDemo {
  14.     public static void main(String[] args) throws InterruptedException {
  15.         Thread thread = new Thread(()->{
  16.             for (int i = 0; i < 100; i++) {
  17.                 if(i == 5){
  18.                     LockSupport.park();
  19.                     System.out.println("t当前时间："+ System.currentTimeMillis() /1000);
  20.                 }
  21.                 System.out.println(i);
  22.                 try {
  23.                     TimeUnit.SECONDS.sleep(1);
  24.                 } catch (InterruptedException e) {
  25.                     e.printStackTrace();
  26.                 }
  27.             }
  28.         });
  30.         thread.start();
  31.         TimeUnit.SECONDS.sleep(2);
  32.         // 若在park前执行unpark会导致park无效
  33.         LockSupport.unpark(thread);  
  34. //        System.out.println("当前时间："+ System.currentTimeMillis() / 1000);
  35.     }
  36. }

锁的升级

无锁

偏向锁

markword 中记录了执行线程的id，此时没有其他线程竞争

轻量级锁（自旋）

当有其他线程竞争时，就会进入自旋等待锁的释放，自旋超过10次后进入重量级锁

重量级锁

进入os获取锁的资源

volatile

可见性

硬件层面保证数据一致性

锁总线

MESI

  1. modified
  2. exclusive
  3. shared
  4. invalid

    有序性（禁止指令重排序）

    CAS（compare and swap）

    过程为cpu级别不可中断

    使用

    cas(V,expected,newValue)

    问题：

    ABA

    获取的值和最初值一样，但是中间可能发生了某些改变。比如说：1 -> 2 -> 1

    解决方法：

    加版本号

    引用

    强

    就普通的引用，当引用指向为null时，原被指向的内存才会被回收 ```java package multiThreading;

/**

  • Created by Intellij IDEA. *
  • @author JonnyJiang
  • @date 2021/8/5 */ public class StrongReference { public static void main(String[] args) {
    1.  M m = new M();
    2.  m = null;
    3.  System.gc();
    } }

class M{ @Override protected void finalize() { System.out.println(“finalize被执行”); } }

  1. <a name="6FQSI"></a>
  2. ## 软
  3. 当内存不足时才会被gc回收
  4. > 在运行时加上jvm参数：-Xms10M -Xmx10M
  6. ```java
  7. package multiThreading;
  9. import java.lang.ref.SoftReference;
  11. /**
  12.  * Created by Intellij IDEA.
  13.  *
  14.  * @author JonnyJiang
  15.  * @date 2021/8/5
  16.  */
  17. public class SoftReferenceDemo {
  18.     public static void main(String[] args){
  19.         SoftReference softReference = new SoftReference<>(new M());
  20.         System.out.println(softReference.get());
  21.         System.gc();
  22.         System.out.println(softReference.get());
  23.         byte[] bytes = new byte[1024*1024*7 - 1024*680]; // 设置过大就会报OOM，过小就不会触发fgc
  24.         System.out.println(softReference.get());
  25.     }
  26. }

image.png

弱

只要gc就会被回收，常用于threadlocal

package multiThreading;

import java.lang.ref.WeakReference;

/**
 * Created by Intellij IDEA.
 *
 * @author JonnyJiang
 * @date 2021/8/5
 */
public class WeakReferenceDemo {
    public static void main(String[] args) {
        WeakReference weakReference = new WeakReference<>(new M());
        System.out.println(weakReference.get());
        System.gc();
        System.out.println(weakReference.get());
        System.out.println(weakReference.get());
    }
}

结果：
image.png
image.png
因为在使用threadlocal.set(k,v)时，k=>threadlocal，如果threadlocal指向空，那么threadlocalMap中的key就会造成内存泄漏，久而久之就会造成oom，因此在设计ThreadLocalMap时，它的entry就是设计成weakReference，当发生gc时才会被回收

注意：

使用完了一定要remove，防止造成上述的内存泄漏

虚

形同虚设，根据官方文档解释，在被回收时会将对象放入队列中：

Phantom reference objects, which are enqueued after the collector determines that their referents may otherwise be reclaimed. Phantom references are most often used for scheduling pre-mortem cleanup actions in a more flexible way than is possible with the Java finalization mechanism. If the garbage collector determines at a certain point in time that the referent of a phantom reference is phantom reachable, then at that time or at some later time it will enqueue the reference. In order to ensure that a reclaimable object remains so, the referent of a phantom reference may not be retrieved: The get method of a phantom reference always returns null. Unlike soft and weak references, phantom references are not automatically cleared by the garbage collector as they are enqueued. An object that is reachable via phantom references will remain so until all such references are cleared or themselves become unreachable.

上代码：

package multiThreading;

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

/**
 * Created by Intellij IDEA.
 *
 * @author JonnyJiang
 * @date 2021/8/5
 */
public class PhantomReferenceDemo {
    public static void main(String[] args) throws InterruptedException {

        ReferenceQueue referenceQueue = new ReferenceQueue();
        PhantomReference phantomReference = new PhantomReference<Object>(new M(), referenceQueue);
        phantomReference.enqueue();
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());
    }
}

image.png
大多数用与NIO中记录直接内存（堆外内存）的地址，用于记录被回收的对象的信息，方便以后回收堆外内存

常见的容器

容器.jpg

LinkedBlockingQueue

package multiThreading;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * Created by Intellij IDEA.
 *
 * @author JonnyJiang
 * @date 2021/8/6
 */
public class LinkedBlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue blockingQueue = new LinkedBlockingQueue<>();
        // 阻塞
        System.out.println(blockingQueue.take());
        // 空
        System.out.println(blockingQueue.poll());
       // 报错
        System.out.println(blockingQueue.remove());
    }
}

ArrayBlockingQueue

package multiThreading;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**
 * Created by Intellij IDEA.
 *
 * @author JonnyJiang
 * @date 2021/8/6
 */
public class ArrayBlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(2);
        for (int i = 0; i < 5; i++) {
            // 阻塞
            blockingQueue.put(i);
            // 报错
            blockingQueue.add(i);
            // 不能添加
            System.out.println(blockingQueue.offer(i));
        }
    }
}

PriorityDeque

package multiThreading;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;

/**
 * Created by Intellij IDEA.
 *
 * @author JonnyJiang
 * @date 2021/8/6
 */
public class PriorityBlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> blockingQueue = new PriorityBlockingQueue();
        blockingQueue.put(2);
        blockingQueue.put(1);
        System.out.println(blockingQueue);
    }

}

DelayQueue

package multiThreading;

import com.mysql.cj.jdbc.MysqlDataSource;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * Created by Intellij IDEA.
 *
 * @author JonnyJiang
 * @date 2021/8/6
 */
public class DelayQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<MyTask> blockingQueue = new DelayQueue<>();
        blockingQueue.put(new MyTask("a", 1000));
        blockingQueue.put(new MyTask("b",500));
        for (MyTask myTask : blockingQueue) {
            System.out.println(myTask);
        }

    }

    static class MyTask implements Delayed{

        private String name;
        private long time;

        public MyTask(String name, long time){
            this.name = name;
            this.time = time;
        }

        public String getName(){
            return this.name;
        }

        public long getTime(){
            return this.time;
        }
        @Override
        public long getDelay(TimeUnit unit) {
            return unit.toNanos(time);
        }

        @Override
        public int compareTo(Delayed o) {
            if(this.time < ((MyTask)o).getTime()){
                return -1;
            }else if(this.time > ((MyTask)o).getTime()){
                return 1;
            }else {
                return 0;
            }
        }

        @Override
        public String toString() {
            return "MyTask{" +
                    "name='" + name + '\'' +
                    ", time=" + time +
                    '}';
        }
    }
}

SynchronousQueue

package multiThreading;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * Created by Intellij IDEA.
 *  SynchronousQueue：要求必须先有消费者准备着，然后将元素放入队列中，元素才会被拿，否则一直被阻塞，确保队列中的元素被所有
 *      消费者使用完
 * @author JonnyJiang
 * @date 2021/8/6
 */
public class SynchronousQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        SynchronousQueue<Integer> synchronousQueue = new SynchronousQueue<>();
        new Thread(()->{
            try {
                while (true){
                    System.out.println("到我表演了："+synchronousQueue.take());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        TimeUnit.SECONDS.sleep(1);

        synchronousQueue.put(1);
        synchronousQueue.put(2);


    }
}

LinkedTransferQueue

package multiThreading;

import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TimeUnit;

/**
 * Created by Intellij IDEA.
 *
 * @author JonnyJiang
 * @date 2021/8/6
 */
public class TransferQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        LinkedTransferQueue<Integer> blockingQueue = new LinkedTransferQueue<>();

        new Thread(()->{
            try {
                System.out.println("开始表演："+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
//        System.out.println(blockingQueue.take());
        TimeUnit.SECONDS.sleep(1);
        blockingQueue.put(1);
        blockingQueue.put(2);
        System.out.println(blockingQueue.size());
//        System.out.println(blockingQueue.take());
    }
}

交替打印实现

synchronize+wait/notify

package multiThreading;

/**
 * Created by Intellij IDEA.
 *
 * @author JonnyJiang
 * @date 2021/8/6
 */
public class AlternatePrint {
    static final Object lock = new Object();

    public static void main(String[] args) {
        char[] aI = "123456789".toCharArray();
        char[] aC = "ABCDEFGHI".toCharArray();

        new Thread(()->{
            synchronized (lock){
                for(char c:aI){
                    try {
                        System.out.print(c);
                        lock.wait();
                        lock.notify();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(()->{
            synchronized (lock){
                for(char c:aC){
                    try {
                        System.out.print(c);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

volatile + 自旋

package multiThreading;

/**
 * Created by Intellij IDEA.
 *
 * @author JonnyJiang
 * @date 2021/8/6
 */
public class AlternatePrint {
    static final Object lock = new Object();
    // 先打印数字，在打印字母
    static volatile boolean pI = true;
    static volatile boolean pC = false;

    public static void main(String[] args) {
        char[] aI = "123456789".toCharArray();
        char[] aC = "ABCDEFGHI".toCharArray();

        // 打印数字
        new Thread(()->{
            for(char c:aI){
                if (pI){
                    System.out.print(c);
                    pI = false;
                    pC = true;
                }
                for(;!pI && c != aI[aI.length - 1];){}

            }
        }).start();

        // 打印字母
        new Thread(()->{
            for(char c:aC){
                if (pC){
                    System.out.print(c);
                    pI = true;
                    pC = false;
                }
                for(;!pC && c != aC[aC.length - 1];){}
            }
        }).start();
    }
}

ReentrantLock

注意：wait/notify 不能和reentrantLock一起使用，只能结合synchronized使用，可以通过使用reentrantLock的await/signal来代替

package multiThreading;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by Intellij IDEA.
 *
 * @author JonnyJiang
 * @date 2021/8/6
 */
public class AlternatePrint {

    static final Lock LOCK = new ReentrantLock();
    static final Condition CONDITION = LOCK.newCondition();

    public static void main(String[] args) {
        char[] aI = "123456789".toCharArray();
        char[] aC = "ABCDEFGHI".toCharArray();

        new Thread(()->{
            try{
                LOCK.lock();
                for (char c:aI){
                    System.out.print(c);
                    CONDITION.await();
                    CONDITION.signal();
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                LOCK.unlock();
            }

        }).start();

        new Thread(()->{
            try{
                LOCK.lock();
                for (char c:aC){
                    System.out.print(c);
                    CONDITION.signal();
                    CONDITION.await();
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                LOCK.unlock();
            }
        }).start();
    }
}

LockSupport

package multiThreading;

import java.util.concurrent.locks.LockSupport;


/**
 * Created by Intellij IDEA.
 *
 * @author JonnyJiang
 * @date 2021/8/6
 */
public class AlternatePrint {
    static Thread T1 = null;
    static Thread T2 = null;

    public static void main(String[] args) {
        char[] aI = "123456789".toCharArray();
        char[] aC = "ABCDEFGHI".toCharArray();



        T1 = new Thread(()->{
            for(char c:aI){
                System.out.print(c);
                LockSupport.unpark(T2);
                LockSupport.park();
            }
            LockSupport.unpark(T2);
        });

        T2 = new Thread(()->{
            // 保证数字先打印
            LockSupport.park();
            for(char c:aC){
                System.out.print(c);
                LockSupport.unpark(T1);
                LockSupport.park();
            }
            LockSupport.unpark(T1);
        });

        T1.start();
        T2.start();
    }
}

线程池

拒绝策略

jdk提供了四种。还可以自定义

abort

报错

discard

扔掉

discardOldest

扔掉最老的

CallerRuns

调用者处理任务