1
graph LR
2

3
NEW[新建<br>NEW] --"Thread.start()"--> RUNNABLE[运行<br>RUNNABLE]
4

5
RUNNABLE --"synchronized<br>Lock.lock()"--> BLOCKED[阻塞<br>BLOCKED]--异常--> TERMINATED
6
RUNNABLE --"Object.wait()<br>Thread.join()<br>LockSupport.park()"--> WAITING[等待<br>WAITING]--异常--> TERMINATED
7
RUNNABLE --"Thread.sleep(long millis)<br>Object.wait(long timeout)<br>Thread.join(long timeout)<br>LockSupport.parkNanos()<br>LockSupport.parkUntil()"--> TIMED_WAITING[限时等待<br>TIMED_WAITING]--异常-->TERMINATED
8
RUNNABLE --"运行结束/异常"--> TERMINATED[终止<br>TERMINATED]

1
public enum State {
2
  /* 【新建】
3
   * 尚未启动的线程处于此状态。
4
   */
5
  NEW,
6
  /* 【运行】
7
   * 在Java虚拟机中执行的线程处于此状态。
8
   */
9
  RUNNABLE,
10
  /* 【阻塞】
11
   * 一个阻塞线程在等待获取monitor锁
12
   * tips:当线程调用Object.wait()方法进入一个synchronized块/方法
13
   *      或重进入一个synchronized锁/方法时会等待获取monitor锁。
14
   */
15
  BLOCKED,
16
  /* 【等待】
17
   * 线程处于WAITING状态的场景。
18
   * 调用Object.wait()，未指定超时值。
19
   * 调用Thread.join()，未指定超时值。
20
   * 调用LockSupport.park()。
21
   */
22
  WAITING,
23
  /* 【限时等待】
24
   * 调用Thread.sleep方法
25
   * 调用Object.wait(long timeout)，指定超时值。
26
   * 调用Thread.join(long timeout)，指定超时值。
27
   * 调用LockSupport.parkNanos()。
28
   * 调用LockSupport.parkUntil()。
29
   */
30
  TIMED_WAITING,
31
  /* 【终止】
32
   * 线程已完成执行。
33
   */
34
  TERMINATED;
35
}

1
//无返回值
2
Runnable r = () -> System.out.print("Hello world!");
3
new Thread(r).start();
4
//有返回值
5
Callable<String> c = () -> "Hello world!";
6
FutureTask<String> ft = new FutureTask<>(c);
7
new Thread(ft).start();
8
System.out.print(ft.get());

1
public ReentrantLock() {
2
    sync = new NonfairSync();
3
}
4
public ReentrantLock(boolean fair) {
5
    sync = fair ? new FairSync() : new NonfairSync();
6
}

1
public void run() {
2
  synchronized (this) {
3
    synchronized (this) {
4
    }
5
  }
6
}

1
<dependency>
2
  <groupId>org.openjdk.jol</groupId>
3
  <artifactId>jol-core</artifactId>
4
  <version>0.9</version>
5
</dependency>

1
class User {
2
  int age;
3
  boolean isDead;
4
}
5

6
User user = new User();
7
System.err.println(user); //16进制hashCode
8
System.out.println(ClassLayout.parseInstance(user).toPrintable()); //对象信息

1
User@15db9742
2

3
User object internals:
4
 OFFSET SIZE     TYPE DESCRIPTION                             VALUE
5
      0    4          (object header)       （Mark Word）     01 42 97 db (00000001 01000010 10010111 11011011) (-610844159)
6
      4    4          (object header)       （Mark Word）     15 00 00 00 (00010101 00000000 00000000 00000000) (21)
7
      8    4          (object header)     （Klass pointer）   43 c0 00 f8 (01000011 11000000 00000000 11111000) (-134168509)
8
     12    4      int User.age               （对象属性）      0
9
     16    1  boolean User.isDead            （对象属性）      false
10
     17    7          (loss due to the next object alignment) 对齐填充
11
Instance size: 24 bytes
12
Space losses: 0 bytes internal + 7 bytes external = 7 bytes total

1
Thread.sleep(5000); //JVM加载超过约4s以后，对代码块加上偏向锁
2
User user = new User();
3
System.out.println(ClassLayout.parseInstance(user).toPrintable());
4
//                 偏向锁
5
//                  ↓-↓
6
//05 00 00 00 (00000101 00000000 00000000 00000000) (5)
7
//00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8
//43 c0 00 f8 (01000011 11000000 00000000 11111000) (-134168509)

1
public class Counter {
2
  private final ReadWriteLock rwlock = new ReentrantReadWriteLock();
3
  private final Lock rlock = rwlock.readLock();
4
  private final Lock wlock = rwlock.writeLock();
5
  private int[] counts = new int[10];
6

7
  public void increment(int index) {
8
      wlock.lock(); //加写锁
9
      try {
10
          counts[index] += 1;
11
      } finally {
12
          wlock.unlock(); //释放写锁
13
      }
14
  }
15

16
  public int[] get() {
17
      rlock.lock(); //加读锁
18
      try {
19
          return Arrays.copyOf(counts, counts.length);
20
      } finally {
21
          rlock.unlock(); //释放读锁
22
      }
23
  }
24
}

1
final CountDownLatch count = new CountDownLatch(5);
2

3
//守护线程，等待计数器到达5完成
4
new Thread(() -> {
5
  count.await();
6
  System.out.println("all work-thread finished.");
7
}, "daemon-thread").start();
8

9
//开启5个线程，结束后调用count.countDown()计数递增
10
for (int i = 1; i <= 5; i++) {
11
  new Thread(() -> {
12
    System.out.println(Thread.currentThread().getName() + " finished.");
13
    count.countDown();
14
  }, "work-thread-" + i).start();
15
}
16

17
//结果
18
//work-thread-3 finished.
19
//work-thread-5 finished.
20
//work-thread-4 finished.
21
//work-thread-1 finished.
22
//work-thread-2 finished.
23
//all work-thread finished.

1
final CyclicBarrier barrier = new CyclicBarrier(5);
2

3
for (int i = 1; i <= 5; i++) {
4
  new Thread(() -> {
5
    System.out.println(Thread.currentThread().getName() + " 到达栅栏：" + System.currentTimeMillis());
6
    barrier.await();
7
    System.out.println(Thread.currentThread().getName() + " 冲破栅栏：" + System.currentTimeMillis());
8
  }, "work-thread-" + i).start();
9
}
10

11
//结果
12
//work-thread-1 到达栅栏：1647175690103
13
//work-thread-3 到达栅栏：1647175690104
14
//work-thread-2 到达栅栏：1647175690103
15
//work-thread-5 到达栅栏：1647175690104
16
//work-thread-4 到达栅栏：1647175690105
17

18
//work-thread-4 冲破栅栏：1647175690105
19
//work-thread-1 冲破栅栏：1647175690105
20
//work-thread-2 冲破栅栏：1647175690105
21
//work-thread-3 冲破栅栏：1647175690105
22
//work-thread-5 冲破栅栏：1647175690105

1
final Semaphore semaphore = new Semaphore(2);
2
for (int i = 1; i <= 5; i++) {
3
  new Thread(() -> {
4
    //消费一个许可
5
    semaphore.acquire();
6
    System.out.println(Thread.currentThread().getName() + " 开始，获得许可，当前可用的许可数：" + semaphore.availablePermits());
7
    TimeUnit.SECONDS.sleep(1);
8
    //创建一个许可
9
    semaphore.release();
10
    System.out.println(Thread.currentThread().getName() + " 结束，发布许可，当前可用的许可数：" + semaphore.availablePermits());
11
  }, "work-thread-" + i).start();
12
}
13

14
//结果
15
//work-thread-1 开始，获得许可，当前可用的许可数：0
16
//work-thread-2 开始，获得许可，当前可用的许可数：0
17
//work-thread-2 结束，发布许可，当前可用的许可数：2
18
//work-thread-1 结束，发布许可，当前可用的许可数：2
19
//work-thread-4 开始，获得许可，当前可用的许可数：0
20
//work-thread-3 开始，获得许可，当前可用的许可数：1
21
//work-thread-3 结束，发布许可，当前可用的许可数：2
22
//work-thread-5 开始，获得许可，当前可用的许可数：1
23
//work-thread-4 结束，发布许可，当前可用的许可数：2
24
//work-thread-5 结束，发布许可，当前可用的许可数：2

1
public static ExecutorService newSingleThreadExecutor() {
2
  return new FinalizableDelegatedExecutorService
3
    (new ThreadPoolExecutor(1, 1,
4
                            0L, TimeUnit.MILLISECONDS,
5
                            new LinkedBlockingQueue<Runnable>()));
6
}

1
public static ExecutorService newFixedThreadPool(int nThreads) {
2
  return new ThreadPoolExecutor(nThreads, nThreads,
3
                                0L, TimeUnit.MILLISECONDS,
4
                                new LinkedBlockingQueue<Runnable>());
5
}

1
public static ExecutorService newCachedThreadPool() {
2
  return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
3
                                60L, TimeUnit.SECONDS,
4
                                new SynchronousQueue<Runnable>());
5
}

1
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
2
  return new ScheduledThreadPoolExecutor(corePoolSize);
3
}
4

5
public ScheduledThreadPoolExecutor(int corePoolSize) {
6
  super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
7
        new DelayedWorkQueue());
8
}

1
public ThreadPoolExecutor(int corePoolSize,
2
                          int maximumPoolSize,
3
                          long keepAliveTime,
4
                          TimeUnit unit,
5
                          BlockingQueue<Runnable> workQueue,
6
                          ThreadFactory threadFactory,
7
                          RejectedExecutionHandler handler) {
8
  if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0)
9
    throw new IllegalArgumentException();
10
  if (workQueue == null || threadFactory == null || handler == null)
11
    throw new NullPointerException();
12
  this.acc = System.getSecurityManager() == null ? null : AccessController.getContext();
13
  this.corePoolSize = corePoolSize;
14
  this.maximumPoolSize = maximumPoolSize;
15
  this.workQueue = workQueue;
16
  this.keepAliveTime = unit.toNanos(keepAliveTime);
17
  this.threadFactory = threadFactory;
18
  this.handler = handler;
19
}

1
int N_CPUS = Runtime.getRuntime().availableProcessor();

1
/**
2
 * 这是一个简单的Join/Fork计算过程，将1—1001数字相加
3
 */
4
public class TestForkJoinPool {
5

6
  private static final Integer MAX = 200;
7

8
  static class MyForkJoinTask extends RecursiveTask<Integer> {
9
      // 子任务开始计算的值
10
      private Integer startValue;
11

12
      // 子任务结束计算的值
13
      private Integer endValue;
14

15
      public MyForkJoinTask(Integer startValue , Integer endValue) {
16
          this.startValue = startValue;
17
          this.endValue = endValue;
18
      }
19

20
      @Override
21
      protected Integer compute() {
22
          // 如果条件成立，说明这个任务所需要计算的数值分为足够小了
23
          // 可以正式进行累加计算了
24
          if(endValue - startValue < MAX) {
25
              System.out.println("开始计算的部分：startValue = " + startValue + ";endValue = " + endValue);
26
              Integer totalValue = 0;
27
              for(int index = this.startValue ; index <= this.endValue  ; index++) {
28
                  totalValue += index;
29
              }
30
              return totalValue;
31
          }
32
          // 否则再进行任务拆分，拆分成两个任务
33
          else {
34
              MyForkJoinTask subTask1 = new MyForkJoinTask(startValue, (startValue + endValue) / 2);
35
              subTask1.fork();
36
              MyForkJoinTask subTask2 = new MyForkJoinTask((startValue + endValue) / 2 + 1 , endValue);
37
              subTask2.fork();
38
              return subTask1.join() + subTask2.join();
39
          }
40
      }
41
  }
42

43
  public static void main(String[] args) {
44
      // 这是Fork/Join框架的线程池
45
      ForkJoinPool pool = new ForkJoinPool();
46
      ForkJoinTask<Integer> taskFuture =  pool.submit(new MyForkJoinTask(1,1001));
47
      try {
48
          Integer result = taskFuture.get();
49
          System.out.println("result = " + result);
50
      } catch (InterruptedException | ExecutionException e) {
51
          e.printStackTrace(System.out);
52
      }
53
  }
54
}

1
getstatic   //读取静态变量（count）
2
iconst_1    //定义常量1
3
iadd        //count增加1
4
putstatic   //把count结果同步到主内存

1
            // 线程A  主内存
2
getstatic   //   0      0
3
iconst_1    //   0      8(其他线程自增的值已同步到主内存)
4
iadd        //   1      8
5
putstatic   //   1      1(期望结果是9)

1
volatile static int start = 3;
2
volatile static int end = 6;
3

4
//线程A执行如下代码：
5
while (start < end){
6
}
7
//线程B执行如下代码：
8
start += 3;
9
end += 3;

1
boolean contextReady = false;
2
//线程A执行如下代码：
3
context = loadContext();
4
contextReady = true;
5
//线程B执行如下代码：
6
while(!contextReady){
7
    sleep(200);
8
}
9
doAfterContextReady(context);

1
boolean contextReady = false;
2
//线程A的代码发生了指令重排
3
contextReady = true;
4
context = loadContext();
5
//线程B执行如下代码：
6
while(!contextReady){
7
    sleep(200);
8
}
9
doAfterContextReady(context);

1
volatile boolean contextReady = false;
2
//线程A执行如下代码：
3
context = loadContext();
4

5
//StoreStore屏障  contextReady被赋值之前保证context=loadContext()可见,成功阻止了指令重排。
6
contextReady = true;
7
//StoreLoad屏障
8

9
//线程B执行如下代码：
10
while(!contextReady){
11
    sleep(200);
12
}
13
doAfterContextReady(context);

1
final AtomicInteger atomicInteger = new AtomicInteger();
2

3
for (int i = 0; i < 5; i++) {
4
  Thread thread = new Thread(() -> {
5
    for (int j = 0; j < 1000; j++) {
6
      atomicInteger.incrementAndGet();
7
    }
8
  });
9
  thread.start();
10
  thread.join();
11
}
12

13
System.out.println(atomicInteger.get());
14

15
//结果：5000

1
/*
2
 * AtomicInteger.incrementAndGet
3
 */
4
public final int incrementAndGet() {
5
  return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
6
}
7

8
/*
9
 * Unsafe.getAndAddInt
10
 * CAS操作
11
 */
12
public final int getAndAddInt(Object var1, long var2, int var4) {
13
  int var5;
14
  do {
15
    //获取当前值
16
    var5 = this.getIntVolatile(var1, var2);
17
  } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
18
  //如果当前值是预期的var5，则设置成 var5（当前值）+ var4（1）
19

20
  return var5;
21
}

1
final AtomicReference<String> str = new AtomicReference<>("A");
2

3
Thread t1 = new Thread(() -> {
4
  Thread.sleep(1000);
5
  str.compareAndSet("A", "B"); //预期是A，修改成B
6
}, "线程1");
7

8
Thread t2 = new Thread(() -> {
9
  str.compareAndSet("A", "C");
10
  str.compareAndSet("C", "A"); //把A改为C又改回A
11
}, "线程2");
12

13
t2.start();
14
t1.start();
15
t1.join();
16
t2.join();
17

18
System.err.println(str.get()); //结果：B

1
final AtomicStampedReference<String> str = new AtomicStampedReference<>("A", 0);
2

3
Thread t1 = new Thread(() -> {
4
  Thread.sleep(1000);
5
  str.compareAndSet("A", "B", 0, 1); //预期值是A，并且stamp是0才修改成B
6
}, "线程1");
7

8
Thread t2 = new Thread(() -> {
9
  str.compareAndSet("A", "C", 0, 1); //stamp=1
10
  str.compareAndSet("C", "A", 1, 2); //把A改为C又改回A stamp=2
11
}, "线程2");
12

13

14
t2.start();
15
t1.start();
16
t1.join();
17
t2.join();
18

19
System.err.println(str.getReference()); //结果：A

1
//简单的实现自旋锁
2
public class SpinLock {
3

4
  final AtomicReference<Object> cas = new AtomicReference<>();
5

6
  public void lock() {
7
    Thread current = Thread.currentThread();
8
    // 利用CAS
9
    while (!cas.compareAndSet(null, current)) ;
10
  }
11

12
  public void unlock() {
13
    Thread current = Thread.currentThread();
14
    cas.compareAndSet(current, null);
15
  }
16

17
}