并发编程解惑之线程

并发编程解惑之线程

一、线程与进程

​进程是资源分配的最小单位，每个进程都有独立的代码和数据空间，一个进程包含 1 到 n 个线程。线程是 CPU 调度的最小单位，每个线程有独立的运行栈和程序计数器，线程切换开销小。

​Java 程序总是从主类的 main 方法开始执行，main 方法就是 ​Java 程序默认的主线程，而在 main 方法中再创建的线程就是其他线程。在 ​Java 中，每次程序启动至少启动 2 个线程。一个是 main 线程，一个是垃圾收集线程。每次使用 ​Java 命令启动一个 ​Java 程序，就相当于启动一个 JVM 实例，而每个 JVM 实例就是在操作系统中启动的一个进程。

二、线程的创建方式

​多线程可以通过继承或实现接口的方式创建。

2.1 直接继承 Thread 类实现多线程

​Thread 类是 JDK 中定义的用于控制线程对象的类，该类中封装了线程执行体 run() 方法。需要强调的一点是，线程执行先后与创建顺序无关。

​

/\*\* \* 类MyThread \*/
   public class MyThread extends Thread {

   int nTime;

   String strThread;

   public MyThread(int nTime, String strThread) {

       this.nTime = nTime;

       this.strThread = strThread;
   }

   //线程执行体
   public void run() {
       while (true) {
           try {

               System.out.println("Thread name:" + strThread + " ");

   //线程睡眠，睡眠完成后继续执行
               Thread.sleep(nTime);

           } catch (Exception e) {

               e.printStackTrace();
           }
       }
   }

   //main方法是主线程
   static public void main(String args[]) {
   //额外创建了三个MyThread线程
       MyThread aThread = new MyThread(1000, "aThread");

       aThread.start();

       MyThread bThread = new MyThread(2000, "bThread");

       bThread.start();

       MyThread cThread = new MyThread(3000, "cThread ");

   //调用线程对象的start方法，线程会以多线程的方式并发执行，
   //如果直接调用run方法，线程是直接执行普通方法，并不是并发运行
       cThread.start();

   }
   }

2.2 通过 Runnable 接口实现多线程

/\*\* \* 类MyRunnable \*/
   public class MyRunnable implements Runnable{

       int nTime;

       String strThread;

       public MyRunnable(int nTime, String strThread) {

           this.nTime = nTime;

           this.strThread = strThread;

       }

   @Override
   public void run() {
       while (true) {
           try {

               System.out.println("Thread name:" + strThread + " ");

   //线程睡眠，睡眠完成后继续执行
               Thread.sleep(nTime);

           } catch (Exception e) {

               e.printStackTrace();

           }
       }
   }

       //main方法是主线程
       static public void main(String args[]) {

           //对象实例的运行线程
           Thread aRunnable = new Thread(new MyRunnable(1000, "aRunnable"));

           aRunnable.start();

           Thread bRunnable = new Thread(new MyRunnable(2000, "bRunnable"));

           bRunnable.start();

           Thread cRunnable = new Thread(new MyRunnable(3000, "cRunnable"));

           cRunnable.start();

       }

   }

​通过 Runnable 方式创建线程相比通过继承 Thread 类创建线程的优势是避免了单继承的局限性。若一个 boy 类继承了 person 类，boy 类就无法通过继承 Thread 类的方式来实现多线程。

​使用 Runnable 接口创建线程的过程：先是创建对象实例 MyRunnable，然后将对象 My Runnable 作为 Thread 构造方法的入参，来构造出线程。对于 new Thread(Runnable target) 创建的使用同一入参目标对象的线程，可以共享该入参目标对象 MyRunnable 的成员变量和方法，但 run() 方法中的局部变量相互独立，互不干扰。

上面代码是 new 了三个不同的 My Runnable 对象，如果只想使用同一个对象，可以只 new 一个 MyRunnable 对象给三个 new Thread 使用。

​实现 Runnable 接口比继承 Thread 类所具有的优势：

• 适合多个相同的程序代码的线程去处理同一个资源（使用同一个目标对象），一份代码，多份数据，代码和数据分离
• 可以避免 ​Java 中的单继承的限制
• 线程池只能放入实现 Runable 或 callable 类线程，不能直接放入继承 Thread 类的线程

三、线程的状态

​线程有新建、可运行、阻塞、等待、定时等待、死亡 6 种状态。一个具有生命的线程，总是处于这 6 种状态之一。 每个线程可以独立于其他线程运行，也可和其他线程协同运行。线程被创建后，调用 start() 方法启动线程，该线程便从新建态进入就绪状态。

3.1 新建状态

NEW 状态（新建状态） 实例化一个线程之后，并且这个线程没有开始执行，这个时候的状态就是 NEW 状态：

Thread thread = new Thread(); 

System.out.println(thread.getState()); 

// NEW 状态（thread.getState()获取线程状态）。 

3.2 就绪状态

RUNNABLE 状态（就绪状态）：

static public void main(String args[]) {

Thread thread = new Thread(

 // 创建runnable入参对象
new Runnable() { 

@Override public void run() { 

System.out.println(thread.getState());

} 
},

 // 线程名称
 "RUNNABLE-Thread"); 

// 线程启动后就是runnable状态，正在运行的状态
thread.start(); 
}

3.3 阻塞状态

​阻塞状态有 3 种：

• 等待阻塞：运行的线程执行了 wait() 方法，释放持有的锁，JVM 会把该线程放入等待队列（等待池）中。
• 同步阻塞：运行线程获取同步锁时，而同步锁被其他线程持有，则 JVM 会把线程放入同步队列（锁池）中。
• 其他阻塞：运行的线程执行 sleep() 或 join() 方法，JVM 会把该线程置为阻塞状态。当 sleep() 状态超时、join() 等待的线程结束了或者超时，线程会重新转入就绪状态。当运行线程发出了 I/O 请求时，一样会变成阻塞状态，直到 I/O 处理完毕，才变成就绪状态。

3.4 等待状态

​如果一个线程调用了一个对象的 wait 方法， 那么这个线程就会处于等待状态（waiting 状态）直到另外一个线程调用这个对象的 notify 或者 notifyAll 方法后才会解除这个状态。

static public void main(String args[]) {

final Object lock = new Object();

Thread threadA = new Thread(new Runnable() {

    @Override public void run() {

        synchronized (lock) {
            try {

//当前线程释放持有的lock锁，并等待lock锁的分配
                lock.wait();
//等待结束
                System.out.println("wait over");

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}, "WAITING-Thread-A");

Thread threadB = new Thread(new Runnable() {

    @Override public void run() {

        synchronized (lock) {

//当前线程唤醒等待队列里的线程，让线程进入就绪队列申请lock锁
//但是本线程仍然继续拥有lock这个同步锁，本线程仍然继续执行 
            lock.notifyAll();
            try {

// 当前线程睡眠2000毫秒
                Thread.sleep(2000);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}, "WAITING-Thread-B");

threadA.start();

threadB.start();

}

3.5 终结状态

​run() 里的代码执行完毕后，线程进入终结状态（TERMINATED 状态）。

3.6 小结

​线程状态有 6 种：新建、可运行、阻塞、等待、定时等待、死亡。

四、线程常用的 API

• Thread.currentThread()：获取当前线程
• thread.isAlive()：某个线程实例是否存活。
• Thread.sleep()：sleep 方法是 static 方法，线程类和线程实例调用，效果一样
• thread.interrupt()：将某个线程的中断标志位设置为 true，并没有中断线程，它只是向线程发送一个中断信号。
• Thread.interrupted()：判断当前线程是否中断，如果发现是 true，表明线程是中断，返回 true，返回前将标志位设置为 false
• thread.isInterrupted()：判断线程是否中断，不改变标志位
• Object.wait()：让获得 Object 锁的 thread 线程等待
• Object.notify()：唤醒获得 Object 锁的 thread 线程
• Object.wait() 与 Object.notify() 必须要与 synchronized (Object) 一起使用
• thread.join()：等待 thread 线程终止

我们看下 join 方法的使用：

    public class JoinTest {

        public static void main(String[] args) {

            System.out.println(Thread.currentThread().getName() + "主线程运行开始!");

            MyThreads m1 = new MyThreads("A");

            MyThreads m2 = new MyThreads("B");

            m1.start();

            m2.start();

            try {

                //等待A线程运行结束后，main线程和B线程才能继续执行
                m1.join();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {

                //等待B线程运行结束后，main线程才能继续执行
                m2.join();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "主线程运行结束!");

        }

    }

    class MyThreads extends Thread {

        private String name;

        public MyThreads(String name) {
            super(name);
            this.name = name;
        }

        public void run() {

            System.out.println(Thread.currentThread().getName() + " 子线程运行开始!");

            try {

                sleep((int) Math.random() * 10);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + " 子线程运行结束!");
        }

    }

运行结果：

    main主线程运行开始!
    A 子线程运行开始!
    B 子线程运行开始!
    A 子线程运行结束!
    B 子线程运行结束!
    main主线程运行结束!

• thread.yield()： yield() 是让当前运行中的线程回到就绪状态（可运行状态），以允许具相同优先级的其他线程获得运行机会。使得相同优先级的线程之间能适当的轮流执行。但实际中无法保证 yield() 达到让步目的，让步的线程还是有可能被调度到继续执行。

我们来看下 yield 方法的使用：

    public class YieldTest {

        public static void main(String[] args) {

            ThreadInstance y1 = new ThreadInstance("A");

            ThreadInstance y2 = new ThreadInstance("B");

            y1.start();

            y2.start();

        }

    }

    class ThreadInstance extends Thread {

        public ThreadInstance(String name) {

            super(name);

        }

        @Override
        public void run() {

            for (int i = 1; i <= 5; i++) {

                System.out.println("" + this.getName() + "-----" + i);

                // 当i等于10时，就把对CPU的占用释放，让自己或者同优先级的其他线程运行，谁抢到CPU时间片谁就执行
                if (i == 3) {

                    this.yield();

                }
            }
        }

    }

运行结果：

    B-----1
    B-----2
    B-----3
    B-----4
    B-----5
    A-----1
    A-----2
    A-----3
    A-----4
    A-----5

五、线程间的通信

​线程与线程之间是无法直接通信的，A 线程无法直接通知 B 线程，Java 中线程之间交换信息是通过共享的内存来实现的，控制共享资源的读写的访问，使得多个线程轮流执行对共享数据的操作，线程之间通信是通过对共享资源上锁或释放锁来实现的。线程排队轮流执行共享资源，这称为线程的同步。

5.1 线程的通信方式

​Java 提供了很多同步操作（也就是线程间的通信方式），同步可使用 synchronized 关键字、Object 类的 wait/notifyAll 方法、ReentrantLock 锁、无锁同步 CAS 等方式来实现。

5.2 ReentrantLock 锁

​ReentrantLock 是 JDK 内置的一个锁对象，用于线程同步（线程通信），需要用户手动释放锁。

public class ReentrantLockTest {
// 创建锁对象
    private ReentrantLock lock = new ReentrantLock();

    public void work() {
        lock.lock();//对下面的操作上锁，只有拿到锁，才能继续执行
        try {
            System.out.println(Thread.currentThread().getName() );
            try {
                Thread.sleep(6000);
            } catch (InterruptedException e) {

            }
        } finally {
        // 就算出现异常，也确保能释放锁
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockTest reentrantLockTest = new ReentrantLockTest();
        Thread thread1 = new Thread(new Runnable() {
            @Override public void run() {
            // 创建线程1执行同步方法work，需要拿到锁才能执行try里的代码
                reentrantLockTest.work();
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override public void run() {
           // 创建线程2执行同步方法work，需要拿到锁才能执行try里的代码
                reentrantLockTest.work();
            }
        });
        //启动两个线程
        thread1.start();
        thread2.start();
    }

}

​运行结果：

Thread-0 
// 隔了6秒钟 输入下面
Thread-1 

​这表明同一时间段只能有 1 个线程执行 work 方法，因为 work 方法里的代码需要获取到锁才能执行，这就实现了多个线程间的通信，线程 0 获取锁，先执行，线程 1 等待，线程 0 释放锁，线程 1 继续执行。

5.3 synchronized 内置锁

​synchronized 是一种语法级别的同步方式，称为内置锁。该锁会在代码执行完毕后由 JVM 释放。

public class SynchronizedTest {

//synchronized放在返回值后，对work方法上锁，锁住的是SynchronizedTest该类的对象实例
    public synchronized void work() {
        try {

            nextLock();

            Thread.sleep(6000);

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) {

        SynchronizedTest reentrantLockTest = new SynchronizedTest();

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {

                reentrantLockTest.work();
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {

                reentrantLockTest.work();
            }
        });

        //启动两个线程，这两个线程都调用同一个对象实例reentrantLockTest的work方法

        //这两次调用需要竞争的是同一个锁对象reentrantLockTest，故能实现线程间的同步

        thread1.start();

        thread2.start();
    }

}

​输出结果跟 ReentrantLock 一样。

Thread-0
等待了6秒后
Thread-1

5.4 wait/notifyAll 方式

​Java 中的 Object 类默认是所有类的父类，该类拥有 wait、 notify、notifyAll 方法，其他对象会自动继承 Object 类，可调用 Object 类的这些方法实现线程间的通信。

public class WaitNotifyAllTest {

    public synchronized void doWait() {

       //进入到方法内部，表明线程获取到了锁，锁就是WaitNotifyAllTest对应的对象实例，this代表该实例
        try {

        // 此时释放了锁，其他线程可获得锁并执行

            this.wait();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

    }

    public synchronized void doNotify() {

    //进入到方法，表明获取到了锁
        try {

            Thread.sleep(6000);

            //通知其他线程竞争锁，此时锁还未被释放
            this.notifyAll();

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();
        }

        //方法结束，锁被自动释放，其他线程终于可以申请锁了
    }

    public static void main(String[] args) {

        WaitNotifyAllTest waitNotifyAllTest = new WaitNotifyAllTest();

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {

                waitNotifyAllTest.doWait();
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {

                waitNotifyAllTest.doNotify();
            }
        });

        thread1.start();

        thread2.start();
    }

}

5.5 无锁同步 CAS

​除了可以通过锁的方式来实现通信，还可通过无锁的方式来实现，无锁同 CAS（Compare-and-Swap，比较和交换）的实现，需要有 3 个操作数：内存地址 V，旧的预期值 A，即将要更新的目标值 B，当且仅当内存地址 V 的值与预期值 A 相等时，将内存地址 V 的值修改为目标值 B，否则就什么都不做。

​我们通过计算器的案例来演示无锁同步 CAS 的实现方式，非线程安全的计数方式如下：

/\*\* \* 非线程安全计数器 \*/
private void count() {
    i++;
}

​线程安全的计数方式如下：

//基于CAS实现线程安全的计数器方法safeCount
public class CountAtomic {

    private AtomicInteger atomic = new AtomicInteger(0);

    private int i = 0;

     /\*\* \* 使用CAS实现线程安全计数器 \*/
    private void safeCount() {
        for (;;) {

//获取原子类实例值0（初始值为0）
            int i = atomic.get();

//实例值0和预期值0相同，设置实例值为1
            boolean sum = atomic.compareAndSet(i, ++i);
            if (sum) {

//无限循环，直到sum值为true，设置成功，退出循环，设置失败，不断循环判断，不断重试，类似自旋锁
                break;
            }
        }
    }

/\*\* \* 非线程安全计数器 \*/
private void count() {
    i++;
}

//调用main方法，测试两种计数方法
    public static void main(String[] args) {

        final CountAtomic cas = new CountAtomic();

        List<Thread> ts = new ArrayList<Thread>();//初始值为600

        for (int j = 0; j < 100; j++) {
            Thread t = new Thread(new Runnable() {
                @Override public void run() {

                    for (int i = 0; i < 1000; i++) {

                        cas.count();

                        cas.safeCount();

                    }
                }
            });

//将线程加入队列
            ts.add(t);
        }
//启动所有线程
        for (Thread t : ts) {
            t.start();
        }

        // 等待所有线程执行完成
        for (Thread t : ts) {
            try {

//在线程A中调用了线程B的Join()方法,是A线程进入wait状态,直到线程B执行完毕后,才会继续执行线程A
//这是让main线程进入等待，直到所有t线程执行完，才继续执行main线程
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("非线程安全累加结果"+cas.i);
        System.out.println("线程安全累加结果"+cas.atomic.get());
    }

}

​运行结果：

非线程安全累加结果98636
线程安全累加结果100000

​线程安全累加的结果才是正确的，非线程安全会出现少计算值的情况。JDK 1.5 开始，并发包里提供了原子操作的类，AtomicBoolean 用原子方式更新的 boolean 值，AtomicInteger 用原子方式更新 int 值，AtomicLong 用原子方式更新 long 值。 AtomicInteger 和 AtomicLong 还提供了用原子方式将当前值自增 1 或自减 1 的方法，在多线程程序中，诸如 ++i 或 i++ 等运算不具有原子性，是不安全的线程操作之一。 通常我们使用 synchronized 将该操作变成一个原子操作，但 JVM 为此种操作提供了原子操作的同步类 Atomic，使用 AtomicInteger 做自增运算的性能是 ReentantLock 的好几倍。

六、J.U.C 包

​上面我们都是使用底层的方式实现线程间的通信的，但在实际的开发中，我们应该尽量远离底层结构，使用封装好的 API，例如 J.U.C 包（java.util.concurrent，又称并发包）下的工具类 CountDownLath、CyclicBarrier、Semaphore，来实现线程通信，协调线程执行。

6.1 闭锁 CountDownLatch

​CountDownLatch 能够实现线程之间的等待，CountDownLatch 用于某一个线程等待若干个其他线程执行完任务之后，它才开始执行。

CountDownLatch 类只提供了一个构造器：

   public CountDownLatch(int count) {  };  //参数count为计数值

CountDownLatch 类中常用的 3 个方法：

• await() 方法：调用 await() 方法的线程会被挂起，它会等待直到 CountDownLatch 的 count 值为 0 才继续执行。

  public void await() throws InterruptedException { };

• 带时间的 await() 方法，等待一定的时间后 CountDownLatch 的 count 值还没变为 0 的话就会继续执行。

  public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };

• 将 CountDownLatch 的 count 值减 1。

  public void countDown() { };

public class CountDownLatchTest {

    public static void main(String[] args) {

        final CountDownLatch latch = new CountDownLatch(2);

        new Thread() {
            public void run() {
                try {
                    System.out.println("子线程" + Thread.currentThread().getName() + "正在执行");

                    Thread.sleep(3000);

                    System.out.println("子线程" + Thread.currentThread().getName() + "执行完毕");

                    latch.countDown();

                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }

            ;
        }.start();

        new Thread() {
            public void run() {
                try {

                    System.out.println("子线程" + Thread.currentThread().getName() + "正在执行");

                    Thread.sleep(2000);

                    System.out.println("子线程" + Thread.currentThread().getName() + "执行完毕");

                    latch.countDown();

                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }

            ;
        }.start();

        try {

            System.out.println("main线程等待2个子线程执行完毕");

            latch.await();

            System.out.println("2个子线程已经执行完毕");

            System.out.println("main线程继续执行");

        } catch (InterruptedException e) {

            e.printStackTrace();
        }
    }

}

运行结果：

main线程等待2个子线程执行完毕
子线程Thread-1正在执行
子线程Thread-0正在执行
子线程Thread-1执行完毕
子线程Thread-0执行完毕
2个子线程已经执行完毕
main线程继续执行

6.2 循环栅栏 CyclicBarrier

​CyclicBarrier 字面意思循环栅栏，通过它可以让一组线程等待至某个状态之后再全部同时执行。当所有等待线程都被释放以后，CyclicBarrier 可以被重复使用，所以有循环之意。

​相比 CountDownLatch，CyclicBarrier 可以被循环使用，而且如果遇到线程中断等情况时，可以利用 reset() 方法，重置计数器，CyclicBarrier 会比 CountDownLatch 更加灵活。

CyclicBarrier 提供 2 个构造器：

    public CyclicBarrier(int parties, Runnable barrierAction) {

    }

    public CyclicBarrier(int parties) {

    }

上面的方法中，参数 parties 指让多少个线程或者任务等待至 barrier 状态；参数 barrierAction 为当这些线程都达到 barrier 状态时会执行的内容。

CyclicBarrier 中最重要的方法 await 方法，它有 2 个重载版本。下面方法用来挂起当前线程，直至所有线程都到达 barrier 状态再同时执行后续任务。

    public int await() throws InterruptedException, BrokenBarrierException { 

    };

而下面的方法则是让这些线程等待至一定的时间，如果还有线程没有到达 barrier 状态就直接让到达 barrier 的线程执行任务。

    public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException { 

    };

     public class CyclicBarrierTest {

       public static void main(String[] args) {

           Random random = new Random();

           CyclicBarrier cyclicBarrier = new CyclicBarrier(5);

       //启动5个线程，对应cyclicBarrier设置的让5个线程等待至barrier状态

           for (int i = 0; i < 5; i++) {

               new Thread(new Runnable() {

                   @Override public void run() {

                       int secs = random.nextInt(5);

                       System.out.println("线程" + Thread.currentThread().getName() + "正在写入数据");
                       try {

                           //以睡眠来模拟写入数据操作

                           Thread.sleep(secs * 1000);

                           System.out.println("线程" + Thread.currentThread().getName() + "写入数据完毕，等待其他线程写入完毕");

                           cyclicBarrier.await();

                       } catch (InterruptedException e) {

                           e.printStackTrace();

                       } catch (BrokenBarrierException e) {

                           e.printStackTrace();
                       }

                       System.out.println("所有线程写入完毕，继续处理其他任务");
                   }

               }).start();
           }
       }

    }

运行结果：

    线程Thread-0正在写入数据
    线程Thread-3正在写入数据
    线程Thread-4正在写入数据
    线程Thread-1正在写入数据
    线程Thread-2正在写入数据
    线程Thread-3写入数据完毕，等待其他线程写入完毕
    线程Thread-2写入数据完毕，等待其他线程写入完毕
    线程Thread-0写入数据完毕，等待其他线程写入完毕
    线程Thread-1写入数据完毕，等待其他线程写入完毕
    线程Thread-4写入数据完毕，等待其他线程写入完毕
    所有线程写入完毕，继续处理其他任务
    所有线程写入完毕，继续处理其他任务
    所有线程写入完毕，继续处理其他任务
    所有线程写入完毕，继续处理其他任务
    所有线程写入完毕，继续处理其他任务

CyclicBarrier 用于一组线程互相等待至某个状态，然后这一组线程再同时执行，CountDownLatch 是不能重用的，而 CyclicBarrier 可以重用。

6.3 信号量 Semaphore

​Semaphore 类是一个计数信号量，它可以设定一个阈值，多个线程竞争获取许可信号，执行完任务后归还，超过阈值后，线程申请许可信号时将会被阻塞。Semaphore 可以用来 构建对象池，资源池，比如数据库连接池。

​假如在服务器上运行着若干个客户端请求的线程。这些线程需要连接到同一数据库，但任一时刻只能获得一定数目的数据库连接。要怎样才能够有效地将这些固定数目的数据库连接分配给大量的线程呢？

​给方法加同步锁，保证同一时刻只能有一个线程去调用此方法，其他所有线程排队等待，但若有 10 个数据库连接，也只有一个能被使用，效率太低。另外一种方法，使用信号量，让信号量许可与数据库可用连接数为相同数量，10 个数据库连接都能被使用，大大提高性能。

​

public class SemaphoreDemo {

    // 请求总数（客户端请求）
    public static int clientTotal = 10;

    // 同时并发执行的线程数（服务端连接数）
    public static int threadTotal = 2;

    public static void main(String[] args) throws Exception {

// 创建缓存线程池
        ExecutorService executorService = Executors.newCachedThreadPool();

// 创建许可数和线程数一样，表示最多2个线程同时运行
        final Semaphore semaphore = new Semaphore(threadTotal);

// 闭锁countDownLatch的计数设置为10
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);

        for (int i = 0; i < clientTotal; i++) {

            final int count = i;

            executorService.execute(() -> {

                try {

// 申请许可
                    semaphore.acquire();

// 睡眠1秒（实际中为具体业务代码）
                    resolve(count);

// 释放许可。使得每隔一秒就有两个线程执行
                    semaphore.release();

                } catch (Exception e) {

                    log.error("exception", e);
                }

// for循环每执行一次，计数器就减1
                countDownLatch.countDown();
            });
        }

// main线程一直阻塞，直到countDownLatch计数为0
        countDownLatch.await();

// 关闭线程池
        executorService.shutdown();

    }

    private static void resolve(int i) throws InterruptedException {

        Thread.sleep(1000);

    }

}

​上面三个工具类是 J.U.C 包的核心类，J.U.C 包的全景图就比较复杂了：

七、异步线程和线程封闭

7.1 异步线程

​Future 是一种异步执行的设计模式，类似 ajax 异步请求，不需要同步等待返回结果，可继续执行代码。使 Runnable（无返回值不支持上报异常）或 Callable（有返回值支持上报异常）均可开启线程执行任务。但是如果需要异步获取线程的返回结果，就需要通过 Future 来实现了。

Future 是位于 java.util.concurrent 包下的一个接口，Future 接口封装了取消任务，获取任务结果的方法。

public interface Future\<V\> {

//如果取消任务成功则返回true，如果取消任务失败则返回false。

//参数mayInterruptIfRunning表示是否允许取消正在执行的任务，true为允许

  boolean cancel(boolean mayInterruptIfRunning);

//任务是否被取消成功,若是，返回true
    boolean isCancelled();

//任务是否已经完成，若是，返回true
    boolean isDone();

//阻塞获取任务执行结果，一直去获取，直到任务执行完毕返回
    V get() throws InterruptedException, ExecutionException;

//获取执行结果，超时后，未获取到结果，就返回null
    V get(long timeout, TimeUnit unit) ​ throws InterruptedException, ExecutionException, TimeoutException;
}

在 Java 中，一般是通过继承 Thread 类或者实现 Runnable 接口来创建多线程， Runnable 接口不能返回结果，JDK 1.5 之后，Java 提供了 Callable 接口来封装子任务，Callable 接口可以获取返回结果。我们使用线程池提交 Callable 接口任务，将返回 Future 接口添加进 ArrayList 数组，最后遍历 FutureList，实现异步获取返回值。

​

public class FutureDesign {

    public static void main(String[] args) {

        Long start = System.currentTimeMillis();

        ExecutorService exs = Executors.newFixedThreadPool(6);
        try {

            //存储返回结果
            List<Integer> list = new ArrayList<Integer>();

            List<Future<Integer>> futureList = new ArrayList<Future<Integer>>();

            //提交6个任务，每个任务返回一个Future对象，再加入futureList
            for (int i = 0; i < 6; i++) {

                futureList.add(exs.submit(new CallableTask(i + 1)));
            }

            Long getResultStart = System.currentTimeMillis();

            //2.结果归集，用迭代器遍历futureList,高速轮询（模拟并发访问），任务完成就移除
            while (futureList.size() > 0) {

                Iterator<Future<Integer>> iterable = futureList.iterator();

                //如果下一个元素存在
                while (iterable.hasNext()) {

                    //获取下一个元素，future对象
                    Future<Integer> future = iterable.next();

                    //任务完成后或者被取消后
                    if (future.isDone() && !future.isCancelled()) {

                        //获取结果
                        Integer i = future.get();

                        list.add(i);

                        //任务完成，可移除任务
                        iterable.remove();

                    } else {

                        Thread.sleep(1);//避免CPU高速运转，休息1毫秒，CPU运行速度是纳秒级别
                    }
                }
            }

            System.out.println("list=" + list);

            System.out.println("总耗时=" + (System.currentTimeMillis() - start) + "毫秒" + ",取结果归集耗时=" + (System.currentTimeMillis() - getResultStart) + "毫秒");

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            exs.shutdown();

        }
    }

    //回调方法
    static class CallableTask implements Callable\<Integer\> {

        Integer i;

        public CallableTask(Integer i) {
            super();
            this.i = i;
        }

        @Override
        public Integer call() throws Exception {

            Thread.sleep(3000);//任务耗时3秒

            System.out.println("task线程：" + Thread.currentThread().getName() + "任务i=" + i + ",完成！");
            return i;
        }
    }

}

运行结果：

task线程：pool-1-thread-5任务i=5,完成！
task线程：pool-1-thread-2任务i=2,完成！
task线程：pool-1-thread-4任务i=4,完成！
task线程：pool-1-thread-6任务i=6,完成！
task线程：pool-1-thread-3任务i=3,完成！
task线程：pool-1-thread-1任务i=1,完成！
list=[2, 4, 5, 6, 1, 3]
总耗时=3013毫秒,取结果归集耗时=3003毫秒

​上面就是异步线程执行的调用过程，实际开发中用得更多的是使用现成的异步框架来实现异步编程，如 RxJava，有兴趣的可以继续去了解，通常异步框架都是结合远程 HTTP 调用 Retrofit 框架来使用的，两者结合起来用，可以避免调用远程接口时，花费过多的时间在等待接口返回上。

7.2 线程封闭

​线程封闭是通过本地线程 ThreadLocal 来实现的，ThreadLocal 是线程局部变量（local vari able），它为每个线程都提供一个变量值的副本，每个线程对该变量副本的修改相互不影响。

​在 JVM 虚拟机中，堆内存用于存储共享的数据（实例对象），也就是主内存。Thread Local .set()、ThreadLocal.get() 方法直接在本地内存（工作内存）中写和读共享变量的副本，而不需要同步数据，不用像 synchronized 那样保证数据可见性，修改主内存数据后还要同步更新到工作内存。

​Myabatis、hibernate 是通过 threadlocal 来存储 session 的，每一个线程都维护着一个 session，对线程独享的资源操作很方便，也避免了线程阻塞。

​ThreadLocal 类位于 Thread 线程类内部，我们分析下它的源码：

public class Thread implements Runnable {

    ThreadLocal.ThreadLocalMap threadLocals = null;

     public T get() {

        // 得到当前线程
        Thread t = Thread.currentThread();

        // 获取当前线程的ThreadLocalMap容器
        ThreadLocalMap map = getMap(t);

        if (map != null) {

            //容器存在，找到当前线程对应的键值对Entry
            ThreadLocalMap.Entry e = map.getEntry(this);

            if (e != null) {
                @SuppressWarnings("unchecked")

                //获取要返回的值
                T result = (T)e.value;

                return result;
            }
        }

         // 不存在ThreadLocalMap容器，就初始化一个ThreadLocalMap
        return setInitialValue();
    }

    private T setInitialValue() {

        // 初始化ThreadLocalMap
        T value = initialValue();

        Thread t = Thread.currentThread();

        ThreadLocalMap map = getMap(t);

        if (map != null)

        // 实例化ThreadLocalMap之后，将key为当前线程对象，value为null的初始值设置到Map中
            map.set(this, value);

        else
            createMap(t, value);

        return value;
    }

    public void set(T value) {

       // 找到当前线程的ThreadLocalMap，设置对应的值，
        Thread t = Thread.currentThread();

        ThreadLocalMap map = getMap(t);

        if (map != null)

            map.set(this, value);

        else//找不到ThreadLocalMap，创建ThreadLocalMap容器

            createMap(t, value);
    }

    static class ThreadLocalMap {

//ThreadLocalMap容器中存放的就是键值对Entry，Entry的KEY就是ThreadLocal（当前线程），VALUE就是值（共享变量值）。
        static class Entry extends WeakReference\<ThreadLocal\<?\>\> {

             Object value;

            Entry(ThreadLocal<?> k, Object v) {

                super(k);
                value = v;
            }
        }
}

​ThreadLocal 和 Synchonized 都用于解决多线程并发访问的问题，访问多线程共享的资源时，Synchronized 同步机制采用了以时间换空间的方式，提供一份变量让多个线程排队访问，而 ThreadLocal 采用了以空间换时间的方式，提供每个线程一个变量，实现数据隔离。

​ThreadLocal 可用于数据库连接 Connection 对象的隔离，使得每个请求线程都可以复用连接而又相互不影响。

public class ConnectionManager {

        private static ThreadLocal<Connection> connections = new ThreadLocal<Connection>() {

        @Override protected Connection initialValue() {

            Connection conn = null;

            try {

                conn = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/shop", "name","password");

            } catch (SQLException e) {

                e.printStackTrace();

            }

            return conn;
        }
    };

    public static Connection getConnection() {

        return connections.get();
    }

    public static void setConnection(Connection conn) {

        connections.set(conn);
    }

}

7.3 Java 的引用和内存泄漏

​在 ​Java 里面，存在强引用、弱引用、软引用、虚引用。我们主要来了解下强引用和弱引用：

​A a = new A();

​B b = new B();

​上面 a、b 对实例 A、B 都是强引用

​C c = new C(b);

​b = null;

​而上面这种情况就不一样了，即使 b 被置为 null，但是 c 仍然持有对 C 对象实例的引用，而间接的保持着对 b 的强引用，所以 GC 不会回收分配给 b 的空间，导致 b 无法回收也没有被使用，造成了内存泄漏。这时可以通过 c = null; 来使得 c 被回收，但也可以通过弱引用来达到同样目的：

WeakReference c = new WeakReference(b);

​从源码中可以看出 Entry 里的 key 对 ThreadLocal 实例是弱引用：

    static class Entry extends WeakReference\<ThreadLocal\<?\>\> {
         Object value;
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }

​Entry 里的 key 对 ThreadLocal 实例是弱引用，将 key 值置为 null，堆中的 ThreadLocal 实例是可以被垃圾收集器（GC）回收的。但是 value 却存在一条从 Current Tnsparent;text-size-adjust:none;-webkit-font-smoothing:antialiased;box-sizing:border-box;margin:0px 0px 1.1em;outline:0px;">​总结来说，利用 ThreadLocal 来访问共享数据时，JVM 通过设置 ThreadLocalMap 的 Key 为弱引用，来避免内存泄露，同时通过调用 remove、get、set 方法的时候，回收弱引用（Key 为 null 的 Entry）。当使用 static ThreadLocal 的时候（如上面的 Spring 多数据源），static 变量在类未加载的时候，它就已经加载，当线程结束的时候，static 变量不一定会被回收，比起普通成员变量使用的时候才加载，static 的生命周期变长了，若没有及时回收，容易产生内存泄漏。

八、线程池

8.1 线程池的核心参数和作用顺序

​使用线程池，可以重用存在的线程，减少对象创建、消亡的开销，可控制最大并发线程数，避免资源竞争过度，还能实现线程定时执行、单线程执行、固定线程数执行等功能。

​Java 把线程的调用封装成了一个 Executor 接口，Executor 接口中定义了一个 execute 方法，用来提交线程的执行。Executor 接口的子接口是 ExecutorService，负责管理线程的执行。通过 Executors 类的静态方法可以初始化

ExecutorService 线程池。Executors 类的静态方法可创建不同类型的线程池：

newFixedThreadPool 固定线程线程池

newSingleThreadExecutor 单线程线程池

newCachedThreadPool 缓存线程线程池

newScheduledThreadPool 调度线程线程池

​但是，不建议使用 Executors 去创建线程池，而是通过 ThreadPoolExecutor 的方式，明确给出线程池的参数去创建，规避资源耗尽的风险。

​如果使用 Executors 去创建线程池：

• 对于 Executors.newFixedThreadPool() 和 Executors.newSingleThreadExecutor() 线程池： 队列用的是 LinkedBlockingQueue，默认大小为 Integer.MAX_VALUE ，可能会堆积大量的请求（可以无限的添加任务），从而导致内存溢出。
• 对于 Executors.newCachedThreadPool() 和 Executors.ScheduledThreadPool 线程池： 允许的创建的最大线程数量为 Integer.MAX_VALUE，即 2147483647，大量线程的创建会导致严重的性能问题（线程上下文切换带来的开销），线程创建占用堆外内存，任务对象占用堆内内存，大量线程执行任务会导致堆外内存或堆内内存任意一个首先内存溢出。

​最佳的实践是通过 ThreadPoolExecutor 手动地去创建线程池，选取合适的队列存储任务，并指定线程池线程大小。通过线程池实现类 ThreadPoolExecutor 可构造出线程池的，构造函数有下面几个重要的参数：

public ThreadPoolExecutor(int corePoolSize, i nt maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue\<Runnable\> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {   

if (corePoolSize < 0 ||  

maximumPoolSize <= 0 ||   

maximumPoolSize < corePoolSize ||  

keepAliveTime < 0)  

throw new IllegalArgumentException(); 

if (workQueue == null || threadFactory == null || handler == null)  

throw new NullPointerException(); 

this.corePoolSize = corePoolSize;

this.maximumPoolSize = maximumPoolSize; 

this.workQueue = workQueue;   

this.keepAliveTime = unit.toNanos(keepAliveTime); 

this.threadFactory = threadFactory;  

this.handler = handler;}

​参数 1：corePoolSize

线程池核心线程数。

​参数 2：workQueue

阻塞队列，用于保存执行任务的线程，有 4 种阻塞队列可选：

• 基于数组的有界阻塞队列，按 FIFO 先进先出任务的 ArrayBlockingQueue()；
• 基于链表的阻塞队列（可支持有界或无界），按 FIFO 先进先出任务的 LinkedBlockingQueue()；
• 不存储元素的阻塞队列，一个线程插入元素后会被阻塞，直到被其他线程取出元素才会唤醒的 Synchronous Queue（吞吐量高于 LinkedBlockingQueue，是一个无界阻塞队列，理论上可存储无限个元素）；
• 具有优先级的可以针对任务排序的无界阻塞队列 PriorityBlockingQueue()。

关于队列的其他内容，会在并发编程解惑之队列这篇里做详细的介绍。

参数 3：maximunPoolSize

线程池最大线程数。如果阻塞队列满了（有界的阻塞队列），来了一个新的任务，若线程池当前线程数小于最大线程数，则创建新的线程执行任务，否则交给饱和策略处理。如果是无界队列就不存在这种情况，任务都在无界队列里存储着。

​参数 4：RejectedExecutionHandler

拒绝策略，当队列满了，而且线程达到了最大线程数后，对新任务采取的处理策略。

有 4 种策略可选：

• 丢弃新任务并抛出 Rejected Execution Exception 异常的 AbortPolicy 策略
• 直接丢弃新任务不抛出异常的 DiscardPolicy 策略
• 由调用线程处理该任务的 CallerRunsPolicy() 策略
• 丢弃队列最前面的任务，然后重新尝试执行任务（不断重复该过程）的 DiscardOldestPolicy 策略

最后，还可以自定义处理策略。

参数 5：ThreadFactory

创建线程的工厂。

参数 6：keeyAliveTime

线程没有任务执行时最多保持多久时间终止。当线程池中的线程数大于 corePoolSize 时，线程池中所有线程中的某一个线程的空闲时间若达到 keepAliveTime，则会终止，直到线程池中的线程数不超过 corePoolSize。但如果调用了 allowCoreThread TimeOut(boolean value) 方法，线程池中的线程数就算不超过 corePoolSize，keepAlive Time 参数也会起作用，直到线程池中的线程数量变为 0。

参数 7：TimeUnit

配合第 6 个参数使用，表示存活时间的时间单位最佳的实践是通过 ThreadPoolExecutor 手动地去创建线程池，选取合适的队列存储任务，并指定线程池线程大小。

public class FixedThreadPoolTest {

    public static void main(String[] args) {

        ExecutorService es = Executors.newFixedThreadPool(2, Executors.defaultThreadFactory());

        final LinkedBlockingDeque<String> que = new LinkedBlockingDeque<String>();

        for(int i = 1; i <= 10; i ++) {

            //将数字转换成字符串
            que.add(i + "");
        }

        Future<String> result = es.submit(new Callable<String>() {
            @Override public String call() throws Exception {

                while (!que.isEmpty()) {

                    System.out.println(que.poll());
                }

                return "运行完毕";
            }
        });

        System.out.println(result.isDone());

        // get方法会阻塞，直到拿到返回值
        try {

            System.out.println(result.get());

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }

}

运行结果：

false 1 2 3 4 5 6 7 8 9 10 运行完毕

8.2 线程池源码

​线程池创建线程时，会将线程封装成工作线程 Worker，Worker 在执行完任务后，还会不断的去获取队列里的任务来执行。Worker 的加锁解锁机制是继承 AQS 实现的。

private final class Worker extends AbstractQueuedSynchronizer implements Runnable {

    private static final long serialVersionUID = 6138294804551838833L;

    //被封装的线程，就是Worker自己
    final Thread thread;

    //Worker要执行的第一个任务
    Runnable firstTask;

    //记录执行完成的任务数量
    volatile long completedTasks;

    //Worker类构造器
    Worker(Runnable firstTask) {

        setState(-1); // 在worker线程没有启动前是-1状态，无法加锁

        this.firstTask = firstTask;

        this.thread = getThreadFactory().newThread(this);
    }

    // state为0代表没加锁
    // state为1代表加锁了
    //通过CAS尝试加锁，将状态从0设置为1
    //该方法重写了父类AQS的同名方法
    protected boolean tryAcquire(int unused) {

        if (compareAndSetState(0, 1)) {

            setExclusiveOwnerThread(Thread.currentThread());

            return true;
        }

        return false;
    }

    //尝试释放锁，直接将state置为0
    //该方法重写了父类AQS的同名方法
    protected boolean tryRelease(int unused) {

        setExclusiveOwnerThread(null);

        setState(0);

        return true;
    }

    //需要注意的是：tryAcquire与tryRelease是重写了父类AQS的方法，并且不可以直接调用，它们被下面的方法调用，实现加锁和解除
    //加锁 
    //acquire方法是它父类AQS类的方法,方法里会调用tryAcquire方法加锁
    public void lock() {
        acquire(1);
    }

    //尝试加锁
    public boolean tryLock() {
        return tryAcquire(1);
    }

    //解锁 
    //release方法是它父类AQS类的方法，方法里会调用tryRelease方法释放锁
    public void unlock() {
        release(1);
    }

    //返回锁的状态
    public boolean isLocked() {
        return isHeldExclusively();
    }

}

​我们来看下 Worker 线程的运行过程：

//Worker执行任务时会调用run方法
        public void run() {

            runWorker(this);

        }

    final void runWorker(Worker w) {

        Thread wt = Thread.currentThread();

        Runnable task = w.firstTask;// 得到Worker中的任务task（通过addWorker方法提交的任务）

        w.firstTask = null;

        w.unlock(); //允许中断

        boolean completedAbruptly = true;

        try {
            while (task != null || (task = getTask()) != null) {

                w.lock();// 拿到了任务，给Worker上锁，表示当前Worker开始执行任务了
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())

//先判断线程池状态是否允许继续执行任务：
//如果是stop、tidying、terminated状态（这种状态是不接受任务，且不执行任务的），并且线程是非中断状态
//又或者是shutingdown、runing状态 ，并且处于中断状态
//这个时候则中断线程
                    wt.interrupt();
                try {

                    beforeExecute(wt, task);

                    Throwable thrown = null;

                    try {

                        task.run();// 调用task的run方法执行任务，而不是start方法。线程池调用shutdownNow方法可以中断run的运行
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {

                    task = null;
                    w.completedTasks++;
                    w.unlock();// 执行完任务后，解锁Worker，当前Worker线程变成闲置Worker线程
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);// 回收Worker线程
        }
    }

​总结来说，如果当前运行的线程数小于 corePoolSize 线程数，则获取全局锁，然后创建新的线程来执行任务如果运行的线程数大于等于 corePoolSize 线程数，则将任务加入阻塞队列 BlockingQueue 如果阻塞队列已满，无法将任务加入 BlockingQueue，则获取全局所，再创建新的线程来执行任务

​如果新创建线程后使得线程数超过了 maximumPoolSize 线程数，则调用 Rejected ExecutionHandler.rejectedExecution() 方法根据对应的拒绝策略处理任务。

​CPU 密集型任务，线程执行任务占用 CPU 时间会比较长，应该配置相对少的线程数，避免过度争抢资源，可配置 N 个 CPU+1 个线程的线程池；但 IO 密集型任务则由于需要等待 IO 操作，线程经常处于等待状态，应该配置相对多的线程如 2*N 个 CPU 个线程，A 线程阻塞后，B 线程能马上执行，线程多竞争激烈，能饱和的执行任务。线程提交 SQL 后等待数据库返回结果时间较长的情况，CPU 空闲会较多，线程数应设置大些，让更多线程争取 CPU 的调度。

参考资料

• Java 高级 - 多线程机制详解
• Java 并发编程序列之线程状态
• Java 并发编程：CountDownLatch、CyclicBarrier 和 Semaphore
• Java 内存模型与线程
• 原子操作的实现原理
• ThreadLocal 原理及其实际应用
• Spring 动态切换多数据源解决方案
• Java 线程池 ThreadPoolExecutor 源码分析
• Java 多线程编程（三）-Future、FutureTask、CompletableFuture

---

欢迎关注我的公众号，回复关键字“Java” ，将会有大礼相送！！！ 祝各位面试成功！！！