public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()); }

public static ExecutionService newSingleThreadExecutor() { return new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()); }

public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue()); }

1. 线程从 DelayQueue 中获取已到期的 ScheduledFutureTask（DelayQueue.take()）。到期任务是指 ScheduledFutureTask的 time 大于等于当前系统的时间；
2. 执行这个 ScheduledFutureTask；
3. 修改 ScheduledFutureTask 的 time 变量为下次将要被执行的时间；
4. 把这个修改 time 之后的 ScheduledFutureTask 放回 DelayQueue 中（DelayQueue.add())。

//正例1 ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build(); //Common Thread Pool ExecutorService pool = new ThreadPoolExecutor(5, 200, 0L, TimeUnit.MILLISECONDS, //0L keepAliveTime new LinkedBlockingQueue(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy()); pool.execute(()-> System.out.println(Thread.currentThread().getName())); pool.shutdown(); //gracefully shutdown//正例2 ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1, //corePoolSize threadFactory new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());

图片来源：Java并发编程的艺术

private static void test2() { Thread thread = new Thread(() -> { while (true) { Thread.yield(); // 响应中断 if (Thread.currentThread().isInterrupted()) { System.out.println("Java技术栈线程被中断，程序退出。"); return; } } }); thread.start(); thread.interrupt(); }

public final void join() throws InterruptedException { join(0); }

public static native void yield(); //static方法

public static native void sleep(long millis) throws InterruptedException; //static方法

1. 使当前线程暂停运行，把机会交给其他线程
2. 任何线程在等待期间被中断都会抛出InterruptedException

1. wait() 是Object超类中的方法；而sleep()是线程Thread类中的方法
2. 对锁的持有不同，wait()会释放锁，而sleep()并不释放锁
3. 唤醒方法不完全相同，wait() 依靠notify或者notifyAll 、中断、达到指定时间来唤醒；而sleep()到达指定时间被唤醒
4. 调用obj.wait()需要先获取对象的锁，而 Thread.sleep()不用

• 通过扩展Thread类来创建多线程
• 通过实现Runnable接口来创建多线程，可实现线程间的资源共享
• 实现Callable接口，通过FutureTask接口创建线程。
• 使用Executor框架来创建线程池。

/** * @author: 程序员大彬 * @time: 2021-09-11 10:15 */ public class MyThread extends Thread { public MyThread() { }@Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread() + ":" + i); } }public static void main(String[] args) { MyThread mThread1 = new MyThread(); MyThread mThread2 = new MyThread(); MyThread myThread3 = new MyThread(); mThread1.start(); mThread2.start(); myThread3.start(); } }

/** * @author: 程序员大彬 * @time: 2021-09-11 10:04 */ public class RunnableTest { public staticvoid main(String[] args){ Runnable1 r = new Runnable1(); Thread thread = new Thread(r); thread.start(); System.out.println("主线程：["+Thread.currentThread().getName()+"]"); } }class Runnable1 implements Runnable{ @Override public void run() { System.out.println("当前线程："+Thread.currentThread().getName()); } }

1. 资源共享，适合多个相同的程序代码的线程去处理同一个资源
2. 可以避免java中的单继承的限制
3. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类

/** * @author: 程序员大彬 * @time: 2021-09-11 10:21 */ public class CallableTest { public static void main(String[] args) { Callable1 c = new Callable1(); //异步计算的结果 FutureTask result = new FutureTask<>(c); new Thread(result).start(); try { //等待任务完成，返回结果 int sum = result.get(); System.out.println(sum); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } }}class Callable1 implements Callable {@Override public Integer call() throws Exception { int sum = 0; for (int i = 0; i <= 100; i++) { sum += i; } return sum; } }

/** * @author: 程序员大彬 * @time: 2021-09-11 10:44 */ public class ExecutorsTest { public static void main(String[] args) { //获取ExecutorService实例，生产禁用，需要手动创建线程池 ExecutorService executorService = Executors.newCachedThreadPool(); //提交任务 executorService.submit(new RunnableDemo()); } }class RunnableDemo implements Runnable { @Override public void run() { System.out.println("大彬"); } }

1. 当对volatile变量进行写操作的时候，JVM会向处理器发送一条LOCK前缀的指令，将该变量所在缓存行的数据写回系统内存。
2. 由于缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己的缓存是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行置为无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存中。

1. 保证了不同线程对共享变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
2. 禁止进行指令重排序。

• 修饰实例方法，作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁
• 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁（类的字节码文件）
• 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码块前要获得给定对象的锁

public class SynchronizedDemo { public void method() { synchronized (this) { System.out.println("method start"); } } }

1. 如果monitor的进入数entry count为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。
2. 如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1。
3. 如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor。

public class SynchronizedMethod { public synchronized void method() { System.out.println("Hello World!"); } }

• 偏向锁：当线程访问同步块并获取锁时，会在对象头和锁记录中存储锁偏向的线程id，以后该线程进入和退出同步块时，只需简单测试一下对象头的mark word中是否存储着指向当前线程的偏向锁，如果测试成功，则线程获取锁成功，否则，需再测试一下mark word中偏向锁标识是否是1，是的话则使用CAS操作竞争锁。如果竞争成功，则将Mark Word中线程ID设置为当前线程ID，如果CAS获取偏向锁失败，则表示有竞争。当到达全局安全点时获得偏向锁的线程被挂起，偏向锁升级为轻量级锁，然后被阻塞在安全点的线程继续往下执行同步代码。
  偏向锁偏向于第一个获得它的线程，如果程序运行过程，该锁没有被其他线程获取，那么持有偏向锁的线程就不需要进行同步。引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行的开销，因为轻量级锁的获取及释放使用了多次CAS原子指令，而偏向锁只在置换ThreadID的时候使用一次CAS原子指令。当存在锁竞争的时候，偏向锁会升级为轻量级锁。
  适用场景：在锁无竞争的情况下使用，在线程没有执行完同步代码之前，没有其它线程去竞争锁，一旦有了竞争就升级为轻量级锁，升级为轻量级锁的时候需要撤销偏向锁，会做很多额外操作，导致性能下降。
• 轻量级锁
  加锁过程：线程执行同步块之前，JVM会先在当前线程的栈帧中创建用于存储锁记录的空间，并将对象头的mark word复制到锁记录（displaced mark word）中，然后线程尝试使用cas将对象头的mark word替换为指向锁记录的指针。如果成功，则当前线程获得锁，否则表示有其他线程竞争锁，当前线程便尝试使用自旋来获得锁。当自旋超过一定的次数，或者一个线程在持有锁，一个在自旋，又有第三个来访时，轻量级锁升级为重量级锁。
  解锁过程：使用原子的cas操作将displaced mark word替换回到对象头，如果成功则解锁成功，否则表明有锁竞争，锁会膨胀成重量级锁。
  在没有多线程竞争的前提下，使用轻量级锁可以减少传统的重量级锁使用操作系统互斥量（申请互斥锁）产生的性能消耗，因为使用轻量级锁时，不需要申请互斥量。另外，轻量级锁的加锁和解锁都用到了CAS操作。如果没有竞争，轻量级锁使用 CAS 操作避免了使用互斥操作的开销。但如果存在锁竞争，除了互斥量开销外，还会额外发生CAS操作，因此在有锁竞争的情况下，轻量级锁比传统的重量级锁更慢！如果锁竞争激烈，那么轻量级锁将很快膨胀为重量级锁！
  
• 重量级锁：当一个线程获取到锁时，其他线程都会被阻塞住，当持有锁的线程释放锁之后会唤醒这些线程，被唤醒的线程才有机会获取到锁。
  synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中，保证了可见性。
  
• 自旋锁：一般线程持有锁的时间都不是太长，所以仅仅为了这一点时间去挂起线程/恢复线程比较浪费资源。自旋锁就是让该线程等待一段时间，执行一段无意义的循环，不会被立即挂起，看持有锁的线程是否会很快释放锁。如果持有锁的线程很快就释放了锁，那么自旋的效率就非常好，反之，自旋的线程就会白白消耗掉处理的资源，这样反而会带来性能上的浪费。所以自旋的次数必须要有一个限度，如果自旋超过了限定次数仍然没有获取到锁，则应该被挂起。
• 自适应自旋锁：JDK 1.6引入了更加聪明的自旋锁，即自适应自旋锁。所谓自适应就意味着自旋的次数不再是固定的，它是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。
• 锁消除：虚拟机即使编译器在运行时，如果检测到那些共享数据不可能存在竞争，那么就执行锁消除。
• 锁粗化：如果一系列的连续操作都对同一个对象反复加锁和解锁，那么会带来很多不必要的性能消耗，使用锁粗化减少锁操作的开销。

public static final Object get(String key) { r.lock(); try { return map.get(key); } finally { r.unlock(); } }

1. 使用synchronized关键字实现同步，线程执行完同步代码块会自动释放锁，而ReentrantLock需要手动释放锁。
2. synchronized是非公平锁，ReentrantLock可以设置为公平锁。
3. ReentrantLock上等待获取锁的线程是可中断的，线程可以放弃等待锁。而synchonized会无限期等待下去。
4. ReentrantLock 可以设置超时获取锁。在指定的截止时间之前获取锁，如果截止时间到了还没有获取到锁，则返回。
5. ReentrantLock 的 tryLock() 方法可以尝试非阻塞的获取锁，调用该方法后立刻返回，如果能够获取则返回true，否则返回false。

public ReentrantLock() { sync = new NonfairSync(); }public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); }

1. 使用数据版本记录机制实现，这是乐观锁最常用的一种实现方式。给数据增加一个版本标识，一般是通过为数据库表增加一个数字类型的version字段来实现。当读取数据时，将version字段的值一同读出，数据每更新一次，对此version值加一。当我们提交更新的时候，判断数据库表对应记录的当前版本信息与第一次取出来的version值进行比对，如果数据库表当前版本号与第一次取出来的version值相等，则予以更新，否则认为是过期数据。
2. 使用时间戳。数据库表增加一个字段，字段类型使用时间戳（timestamp），和上面的version类似，也是在更新提交的时候检查当前数据库中数据的时间戳和自己更新前取到的时间戳进行对比，如果一致则OK，否则就是版本冲突。

• 悲观锁适合写操作多的场景。
• 乐观锁适合读操作多的场景，不加锁可以提升读操作的性能。

• 需要读写的内存值 V。
• 进行比较的值 A。
• 要写入的新值 B。

1. ABA问题。CAS需要在操作值的时候检查内存值是否发生变化，没有发生变化才会更新内存值。但是如果内存值原来是A，后来变成了B，然后又变成了A，那么CAS进行检查时会发现值没有发生变化，但是实际上是有变化的。ABA问题的解决思路就是在变量前面添加版本号，每次变量更新的时候都把版本号加一，这样变化过程就从A－B－A变成了1A－2B－3A。
   JDK从1.5开始提供了AtomicStampedReference类来解决ABA问题，原子更新带有版本号的引用类型。
   
2. 循环时间长开销大。CAS操作如果长时间不成功，会导致其一直自旋，给CPU带来非常大的开销。
3. 只能保证一个共享变量的原子操作。对一个共享变量执行操作时，CAS能够保证原子操作，但是对多个共享变量操作时，CAS是无法保证操作的原子性的。
   Java从1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，可以把多个变量放在一个对象里来进行CAS操作。
   

public class CountDownLatchDemo { static final int N = 4; static CountDownLatch latch = new CountDownLatch(N); public static void main(String[] args) throws InterruptedException {for(int i = 0; i < N; i++) { new Thread(new Thread1()).start(); }latch.await(1000, TimeUnit.MILLISECONDS); //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行; 等待timeout时间后count值还没变为0的话就会继续执行 System.out.println("task finished"); }static class Thread1 implements Runnable {@Override public void run() { try { System.out.println(Thread.currentThread().getName() + "starts working"); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } finally { latch.countDown(); } } } }

Thread-0starts workingThread-1starts workingThread-2starts workingThread-3starts workingtask finished

public CyclicBarrier(int parties, Runnable barrierAction) {}public CyclicBarrier(int parties) {}

public class CyclicBarrierTest { // 请求的数量 private static final int threadCount = 10; // 需要同步的线程数量 private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5); public static void main(String[] args) throws InterruptedException { // 创建线程池 ExecutorService threadPool = Executors.newFixedThreadPool(10); for (int i = 0; i < threadCount; i++) { final int threadNum = i; Thread.sleep(1000); threadPool.execute(() -> { try { test(threadNum); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (BrokenBarrierException e) { // TODO Auto-generated catch block e.printStackTrace(); } }); } threadPool.shutdown(); }public static void test(int threadnum) throws InterruptedException, BrokenBarrierException { System.out.println("threadnum:" + threadnum + "is ready"); try { /**等待60秒，保证子线程完全执行结束*/ cyclicBarrier.await(60, TimeUnit.SECONDS); } catch (Exception e) { System.out.println("-----CyclicBarrierException------"); } System.out.println("threadnum:" + threadnum + "is finish"); }}

threadnum:0is ready threadnum:1is ready threadnum:2is ready threadnum:3is ready threadnum:4is ready threadnum:4is finish threadnum:3is finish threadnum:2is finish threadnum:1is finish threadnum:0is finish threadnum:5is ready threadnum:6is ready ...

public class SemaphoreDemo {public static void main(String[] args) {final int N = 7; Semaphore s = new Semaphore(3); for(int i = 0; i < N; i++) {new Worker(s, i).start(); }}static class Worker extends Thread {private Semaphore s; private int num; public Worker(Semaphore s, int num) {this.s = s; this.num = num; }@Overridepublic void run() {try {s.acquire(); System.out.println("worker" + num +" using the machine"); Thread.sleep(1000); System.out.println("worker" + num +" finished the task"); s.release(); } catch (InterruptedException e) {e.printStackTrace(); }}}}

worker0 using the machineworker1 using the machineworker2 using the machineworker2 finished the taskworker0 finished the taskworker3 using the machineworker4 using the machineworker1 finished the taskworker6 using the machineworker4 finished the taskworker3 finished the taskworker6 finished the taskworker5 using the machineworker5 finished the task

• AtomicInteger：整型原子类
• AtomicLong：长整型原子类
• AtomicBoolean ：布尔型原子类

public final int get() //获取当前的值 public final int getAndSet(int newValue)//获取当前的值，并设置新的值 public final int getAndIncrement()//获取当前的值，并自增 public final int getAndDecrement() //获取当前的值，并自减 public final int getAndAdd(int delta) //获取当前的值，并加上预期的值 boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update） public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

• AtomicIntegerArray：整形数组原子类
• AtomicLongArray：长整形数组原子类
• AtomicReferenceArray ：引用类型数组原子类

public final int get(int i) //获取 index=i 位置元素的值 public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增 public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减 public final int getAndAdd(int i, int delta) //获取 index=i 位置元素的值，并加上预期的值 boolean compareAndSet(int i, int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update） public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

• AtomicReference：引用类型原子类
• AtomicStampedReference：带有版本号的引用类型原子类。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
• AtomicMarkableReference ：原子更新带有标记的引用类型。该类将 boolean 标记与引用关联起来

private volatile int state; //共享变量，使用volatile修饰保证线程可见性

Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); public void conditionWait() throws InterruptedException { lock.lock(); try { condition.await(); } finally { lock.unlock(); } } public void conditionSignal() throws InterruptedException { lock.lock(); try { condition.signal(); } finally { lock.unlock(); } }

图片来源：Java并发编程的艺术

图片来源：Java并发编程的艺术

图片来源：Java并发编程的艺术

• User Thread(用户线程)
• Daemon Thread(守护线程)

本文已经收录到github仓库，此仓库用于分享Java相关知识总结，包括Java基础、MySQL、Spring Boot、MyBatis、Redis、RabbitMQ、计算机网络、数据结构与算法等等，欢迎大家提pr和star！
github地址：https://github.com/Tyson0314/...
如果github访问不了，可以访问gitee仓库。
gitee地址：https://gitee.com/tysondai/Ja...

推荐阅读

• 

  水果电商为什么这么多假货 水果电商为什么这么多，水果电商为什么这么多广告
• 

  佳能相机能摄影吗 为什么报摄影师都用佳能相机
• 

  如何摆脱过敏体质？ 过敏体质
• 

  赖氏古夷苏木家具怎么样 赖氏家具怎么样
• 

  秘制沙茶酱制作方法大全 秘制沙茶酱制作方法
• 

  Win10添加pin码报错“0x80190001”如何解决？
• 

  西门子燃气灶微动开关故障维修
• 

  冬天有什么水果成熟，冬天的应季水果有哪些知乎
• 

  绘本讲师训练营【17期】13/21阅读原创——《苏菲的杰作》
• 

  黑农48大豆品种介绍，产量如何 黑农84大豆种简介
• 

  如何快速学习韩语
• 

  拿到一款刚买的数码相机。如何检测呢？
• 

  千百块可靠吗 千百块是真的吗 千百块平台介绍
• 

  加湿器的雾变小了是什么原因
• 

  摩托车链条用黄油润滑行不行？使用黄油润滑有何危害？
• 

  不喜欢白天，喜欢晚上
• 

  面部如何控油护肤 面部如何控油，面部如何控油补水
• 

  梦到老婆拿刀来砍我有什么预兆 梦到老婆拿刀来砍我有什么预兆解梦
• 

  如何管理一个营销主管部门，营销管理的方式
• 

  当年万里觅封侯典故 当年万里觅封侯典故是怎么样的呢

• JAVA（抽象类与接口的区别&重载与重写&内存泄漏）
• 知识
• 事件代理
• 小学英语必考的10个知识点归纳，复习必备！
• Java|Java OpenCV图像处理之SIFT角点检测详解
• java中如何实现重建二叉树
• 数组常用方法一
• 【Hadoop踩雷】Mac下安装Hadoop3以及Java版本问题
• 生发知识，带你深入了解
• Java|Java基础——数组