Java 多線程高並發編程 筆記（一）

本篇文章主要是總結Java多線程/高並發編程的知識點，由淺入深，僅作自己的學習筆記，部分侵刪。

一 . 基礎知識點

1. 進程於線程的概念

 

2.線程創建的兩種方式

　　注：public void run（）方法提供了線程實際工作的代碼；

　　　　繼承Thread類的方法存在單繼承的缺陷；

　　　　Runnable的代碼可以被多個線程（Thread實例）共享，適合於多個線程處理統一資源的情況；

3. Thread類的常用方法

　　 

4. Java線程正確停止的方法

　　最常用的方法是設置退出旗標（標志），要注意，stop方法不是正確的方法，它會讓線程戛然而止，interrupt（）方法也不是正確停止線程的方法，它的初衷並不是用於停止線程；

5. 線程交互：互斥與同步

　　互斥：同一時間只能有一個線程去對臨界區進行操作，通過synchronized（intrinsic lock）實現，只有獲得lock的線程才能進入synchronized聲明的代碼塊；

　　同步：線程之間的通信機制；當某些條件不具備時線程處於等待狀態，條件滿足，需要發出消息來喚醒所有線程；通過wait（）/notify（）/notifyAll（）實現。

　　Wait Set：可以理解為線程休息室；

　　共享資源/數據又被稱為臨界區（Critical Section），當有一個線程想要訪問共享資源的時候，首先，他需要獲得鎖，獲得鎖后進入我們的臨界區進行操作，操作過程中，如果發現某些情況不被滿足，將調用鎖對象上的wait()方法，此時，該線程釋放掉鎖資源，然后進入到鎖對象上的Wait Set，由於這個線程釋放掉了我們的鎖資源，使得其他線程可以來競爭多資源，所以其他線程獲得鎖並進入臨界區，同時在鎖對象上的wait set中有多條線程在等待條件的滿足，當我們的當前運行線程執行完某些操作需要通知等待的線程時，調用notify方法將會喚醒所資源所持有的等待區域中的一條線程，是這條線程有機會去進行競爭CPU資源；或者調用notifyAll方法，這時會使wait set中的所有線程被喚醒，從而使得它們有機會在當前線程離開臨界資源釋放鎖之后去競爭臨界資源的鎖對象。

 6. 線程的生命周期

　　

7. 守護線程

　　Java線程有兩類：

　　用戶線程：運行在前台，執行具體的任務；程序的主線程，連接網絡的子線程等都是用戶線程；
　　守護線程：運行在后台，為其他前台線程服務；　

　　守護線程的特點：一旦所有用戶線程都結束運行，守護線程會隨JVm一起結束工作；
　　守護線程的應用：數據庫連接池中的監測線程；JVM虛擬機啟動后的監測線程，最常見的是垃圾回收線程；
　　守護線程的設置：通過調用Thread類的setDaemon(true)方法來設置當前的線程為守護線程；
　　注意：setDaemon（true）必須在start（）方法之前調用，否則會拋出IllegalThreadStateException異常；守護線程中產生的新線程也是守護線程；不是所有的任務都可以分配給守護線程來執行，比如讀寫操作或者計算邏輯；

 

二 . 進階知識點

1. 對象加鎖

1.1 使用synchronized關鍵字對某個對象加鎖

public class T {
    private int count=10;
    private Object o = new Object();
    public void m(){
        synchronized (o){ //任何線程要執行下面代碼，必須先拿到o的鎖
            count--;
            System.out.println(Thread.currentThread().getName()+"count="+count);
        }//執行完了釋放鎖
    }
}

 

在上面的代碼中，鎖是自己new的，每次new出一個沒有其他功能的對象比較麻煩，所以可以用synchronized（this），代碼如下：

public class T {
    private int count = 10;
    public void m(){
        synchronized (this){
            count--;
            System.out.println(Thread.currentThread().getName()+"count="+count);
        }
        /**
         * 上面的代碼可以簡寫為：
         * public synchronized void m(){
         *      count--;
         *      System.out.println(Thread.currentThread().getName()+"count="+count);
         * }
         * 注意：synchronized 鎖定的是對象而不是代碼
         */

    }
}

1.2 synchronized用在靜態方法上

　　類中靜態方法和靜態屬性屬性是不需要new出對象來訪問的，沒有new出來，就沒有this引用的存在，所以當鎖定一個靜態方法時，相當於鎖定的是當前類的class對象。

public class T {
    private static int count = 10;
    public synchronized static void m(){ //這里等同於synchronized(packagename.T.class)
        count--;
        System.out.println(Thread.currentThread().getName()+"count="+count);
    }

    public static void nm(){
        synchronized (T.class){ //是class類的對象
            count--;
        }
    }
}

1.3 鎖住線程的run方法

public class T implements Runnable{
    private int count = 10;
    public synchronized void run(){
        count--;
        System.out.println(Thread.currentThread().getName()+"count="+count);
    }
    public static void main(String[] args){
        T t = new T();//多個線程共同訪問一個Runnable對象
        for(int i=0; i<5; i++){
            new Thread(t,"Thread"+i).start();
        }
    }
}

如果不加synchronized時，count--和打印語句間可能有別的線程執行count--，導致前后數據不一致，加synchronized后方法里的所有語句相當於一個原子操作，只有當run方法執行完了釋放鎖，下一個線程才能拿到鎖執行run方法。

1.4 面試題：同步方法和非同步方法是否可以同時調用？-->可以

public class T {
    public synchronized void m1(){
        System.out.println(Thread.currentThread().getName()+"m1 start...");
        try {
            Thread.sleep(10000);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"m1 end...");

    }
    public void m2(){
        try{
            Thread.sleep(5000);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"m2");
    }

    public static void main(String[] args){
        T t = new T();
        new Thread(t::m1,"t1").start();
        new Thread(t::m2,"t2").start();
    }
}

執行結果：

t1m1 start...
t2m2
t1m1 end...

1.5 對業務寫方法加鎖，對業務讀方法不加鎖，容易產生臟讀

public class Account {
    String name;
    double balance;
    public synchronized void set(String name,double balance){
        this.name = name;
        try{
            Thread.sleep(2000);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        this.balance = balance;
    }

    public double getBalance(String name){
        return this.balance;
    }

    public static void main(String[] args){
        Account a = new Account();
        new Thread(()->a.set("zhangsan",100.0)).start();
        try{
            TimeUnit.SECONDS.sleep(2);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(a.getBalance("zhangsan"));//0.0

        try{
            TimeUnit.SECONDS.sleep(2);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(a.getBalance("zhangsan"));//100.0
    }
}

1.6 一個同步方法可以調用另一個同步方法

一個線程已經擁有某個對象的鎖，再次申請時仍然會得到該對象的鎖

synchronized獲得的鎖是可重入的

public class T {
    synchronized void m1(){
        System.out.println("m1 start");
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        m2();//可調用
    }
    synchronized void m2(){
        try{
            TimeUnit.SECONDS.sleep(2);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("m2");
    }
}

1.7 在繼承中，子類重寫的同步方法可以調用父類的同步方法

public class T {
    synchronized void m(){
        System.out.println("m start");
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("m end");
    }
    public static void main(String[] args){
        new TT().m();
    }

}
class TT extends T{
    synchronized void m(){
        System.out.println("child m start");
        super.m();//可以調用父類的同步方法
        System.out.println("child m end");
    }
}

1.8 出現異常，默認情況下鎖會被釋放

/**
 * 程序在執行過程中如果出現異常，默認情況下鎖會被釋放
 * 所以在執行並發處理的過程中，有異常要小心，不然可能會發生不一致的情況；
 * 比如，在一個web app處理過程中，多個servlet線程共同訪問一個資源
 * 這是如果異常處理不合適，在第一個線程中拋出異常，其他線程就會進入同步代碼區，
 * 有可能會訪問到異常產生時的數據（處理了一半的數據），
 * 因此要非常小心處理同步業務邏輯中的異常
 */

import java.util.concurrent.TimeUnit;
public class T {
    int count = 0;
    synchronized void m(){
        System.out.println(Thread.currentThread().getName()+"start");
        while(true){
            count++;
            System.out.println(Thread.currentThread().getName()+"count"+count);
            try{
                TimeUnit.SECONDS.sleep(1);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            if(count==5){
                int i=1/0;//此處拋出異常，鎖被釋放，要想不被釋放，可以在這里進行catch，然后讓循環繼續

            }
        }
    }
    public static void main(String[] args){
        T t = new T();
        Runnable r = new Runnable(){
            public void run(){
                t.m();
            }
        };
        new Thread(r,"t1").start();
        try{
            TimeUnit.SECONDS.sleep(3);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        new Thread(r,"t2").start();
    }
}

 

2. volatile 關鍵字

2.1 volatile的可見性

　　 volatile 關鍵字，使一個變量在多個線程間可見，A B 線程都用到一個變量，java默認是A線程中保存一份copy，這樣如果B線程修改了該變量，則A未必知道，使用volatile關鍵字，會讓所有線程都會讀到變量的修改值；

　　在下面的代碼中，running 是存在於堆內存對象中，當線程t1開始運行的時候，會把running值從內存中讀到t1線程工作區，在運行過程中直接使用這個copy並不會每次都去讀取堆內存，這樣，當主線程修改running的值之后，t1線程感知不到，所以不會停止運行

　　volatile並不能保證多個線程共同修改running變量時所帶來的不一致問題，也就是說 volatile不能代替synchronized；

public class T {
    volatile boolean running = true;
    void m(){
        System.out.println("m start");
        while(running){

        }
        System.out.println("m end");
    }
    public static void main(String[] args){
        T t = new T();
        new Thread(t::m,"t1").start();
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        t.running = false;
    }
}

volatile 只保證了原子性，而synchronized既保證可見性有保證原子性，但是synchronized太重了；

2.2 volatile不具有原子性

/*10個線程分別執行10000次count++，count是對象vna的成員變量，按理來說最終count=100000，
  但是最終每次執行結果都不一樣，count一直小於100000，說明volatile不具備原子性*/
public class VolatileNoAtomic {
    volatile int count = 0;
    void m() {
        for(int i=0; i<10000; i++) {
            count ++ ;
        }
    }
    public static void main(String[] args) {
        VolatileNoAtomic vna = new VolatileNoAtomic();
        List<Thread> threads = new ArrayList<>();
        for (int i=0; i<10; i++) {
            threads.add(new Thread(vna::m, "thread" + i));
        }
        threads.forEach(o->o.start());
        threads.forEach((o)->{
            try {
                //join()方法阻塞調用此方法的線程,直到線程t完成，此線程再繼續。通常用於在main()主線程內，等待其它線程完成再結束main()主線程。
                o.join(); //相當於在main線程中同步o線程，o執行完了，main線程才有執行的機會
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(vna.count);
    }
}

2.3 synchronized既保證原子性又保證可見性

public class SynVisibleAndAtomic {
    int count = 0;
    synchronized void m() {  //m方法加了synchronized修飾，保證了原子性和可見性
        for (int i=0; i<10000; i++) {
            count ++ ;
        }
    }
    public static void main(String[] args) {
        SynVisibleAndAtomic sva = new SynVisibleAndAtomic();
        List<Thread> threads = new ArrayList<>();
        for (int i=0; i<10; i++) {
            threads.add(new Thread( sva::m , "thread-" + i));
        }
        threads.forEach((o)->o.start());
        threads.forEach((o)-> {
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(sva.count); //100000
    }
}

2.4 面試題：實現一個容器，提供兩個方法add，size，線程1添加10個元素到容器，線程2監控元素的個數，當個數為5時，線程2提示並結束

public class MyContainerVolatile {
    volatile List list = new ArrayList();
    public void add(Object o) {  //add
        list.add(o);
    }
    public int size() {   //size
        return list.size();
    }
 
    public static void main(String[] args) {
        MyContainerVolatile mcv = new MyContainerVolatile();
        new Thread( () -> {  //該線程負責往list里添加
           for (int i=0; i<10; i++) {
               mcv.add(new Object());
               System.out.print(" add-" + i);
               try {
                   Thread.sleep(500);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        },"t1").start();
        new Thread( () -> { //該線程一直監測list的size，直到size=5
            while(true) {  //一直監測着，很浪費CPU
                if(mcv.size() == 5) {  //此處未加同步，仍然可能會出現t1中又一次++為6了，才break
                    break;
                }
            }
            System.out.print(" t2結束 ");
        },"t2").start();
    }
}

上面的代碼能解決問題，但t2線程的死循環很浪費CPU，影響性能！更優方法是使用wait和notify，請參看下例：

public class MyContainerWaitNotify {
    volatile List list = new ArrayList();
    public void add(Object o) {
        list.add(o);
    }
    public int size() {
        return list.size();
    }
 
    public static void main(String[] args) {
        MyContainerWaitNotify mcwn = new MyContainerWaitNotify();
        final Object lock = new Object();
        new Thread(()->{
            synchronized (lock) {
                System.out.print(" ***線程t2啟動*** ");
                if (mcwn.size() != 5) {
                    try {
                        lock.wait();  //size不等於5時，就一直在那等着，直到被t1叫醒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.print(" ***線程t2結束*** ");
                lock.notify();  //通知t1繼續執行
            }
        }, "t2").start();
 
        new Thread(()->{
            synchronized (lock) {
                for(int i=0; i<10; i++) {
                    mcwn.add(new Object());
                    System.out.print(" add-"  + i);
                    if (mcwn.size() == 5) {
                        lock.notify();  //喚醒另一個線程t2，本線程繼續執行，直至synchronized包裹的代碼塊結束或者調用了wait
                        try {
                            lock.wait(); //釋放鎖，讓t2得以執行
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"t1").start();
    }
}

注意：wait會釋放鎖，但notify不會，本代碼會執行到wait或synchronized塊結束才釋放鎖；

但是，上述的方法還是過於繁瑣，Java提供了門閂；

使用CountDownLatch（門閂）的await和countdown方法替代wait和notify方法來進行通知：

public class MyContainerLatch {
    volatile List list = new ArrayList(); //添加volatile，使t2能夠得到通知
    public void add(Object o) {
        list.add(o);
    }
    public int size() {
        return list.size();
    }
 
    public static void main(String[] args) {
        MyContainerLatch mcl = new MyContainerLatch();
        CountDownLatch latch = new CountDownLatch(1);  //當1變成0時，門就開了
        new Thread(() -> {
            System.out.print(" *t2啟動* ");
            if (mcl.size() != 5) {
                try {
                    latch.await();  //等待不需要鎖定一個對象
                    //latch.await(5000,TimeUnit.MILLISECONDS); //也可以指定等待時間
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.print(" *t2結束* ");
        },"t2").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        new Thread(()->{
            System.out.print(" *t1啟動* ");
            for (int i=0; i<10; i++) {
                mcl.add(new Object());
                System.out.print(" add-" + i);
                if (mcl.size() == 5) {
                    latch.countDown(); //打開門閂，讓t2得以執行。調用一次countDown，就減1
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.print(" *t1結束* ");
 
        },"t1").start();
    }
}

這樣做的好處是通信方式簡單，同時也可以指定等待時間。

聲明一個CountDownLatch對象latch並設定初始值>0，調用latch.countDown（）使latch值減一，當latch值變為0，門閂打開；
當不涉及同步，只涉及鎖定，用synchronized+wait/notify就顯得太重了。這時應該考慮CountDownLatch/cyclicbarrier/semephore.

3. 原子變量類（AtomXxx）

　　原子變量最主要的一個特點是所有的操作都是原子的，synchronized關鍵字也能做到對變量的原子操作，但是成本相對較高，需要獲取鎖對象，釋放鎖對象，如果不能獲取到鎖，還需要阻塞在阻塞隊列上進行等待：

public class Counter {
    private int count;

    public synchronized void addCount(){
        this.count++;
    }
}

　　上述代碼使用synchronized關鍵字保證變量原子性，簡單的count++操作，線程首先需要獲得Counter類實例的對象鎖，然后完成自增操作，最后釋放鎖，十分消耗成本，如果不能獲取到鎖，還需要阻塞線程等；

　　對於這種情況，可以將count變量聲明為原子變量，那么對於count的自增操作都可以以原子的方式進行，就不存在臟數據的讀取了；

　　原子變量類一共有12個，可以被分為4組：

常用的基於原子操作的方法：

//基於原子操作，獲取當前原子變量中的值並為其設置新值
public final int getAndSet(int newValue)
//基於原子操作，比較當前的value是否等於expect，如果是設置為update並返回true，否則返回false
public final boolean compareAndSet(int expect, int update)
//基於原子操作，獲取當前的value值並自增一
public final int getAndIncrement()
//基於原子操作，獲取當前的value值並自減一
public final int getAndDecrement()
//基於原子操作，獲取當前的value值並為value加上delta
public final int getAndAdd(int delta)
//還有一些反向的方法，比如：先自增在獲取值的等等

下例展示了使用AtomicInteger來實現int類型的原子性操作：

public class AtomicIntegerTest {
    AtomicInteger count = new AtomicInteger(0);
    void m() {
        for (int i=0; i<10000; i++) {
            count.incrementAndGet(); ////incrementAndGet()-先+1，再返回; getAndIncrement()-先返回，再+1
        }
    }
    public static void main(String[] args) {
        AtomicIntegerTest ait = new AtomicIntegerTest();
        List<Thread> threads = new ArrayList<>();
        for (int i=0; i<10; i++) {
            threads.add(new Thread( ait::m , "thread" + i));
        }
        threads.forEach((o)->o.start());
        threads.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(ait.count); //100000
    }
}

4. ReentrantLock-重入鎖

　　Java中實現鎖通常有兩種方式，一種是使用synchronized關鍵字，另一種是Lock：

4.1 ReentrantLock替代synchronized

public class ReentrantLockTest1 {
    Lock lock = new ReentrantLock();
    void m1() {
        try {
            lock.lock();  //加鎖  //相當於synchronized(this)
            for (int i=0; i<10; i++) {
                TimeUnit.SECONDS.sleep(1);
                System.out.print(" " + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();  //釋放鎖
        }
    }
    void m2() {
        lock.lock();  //加鎖
        System.out.print(" m2()... ");
        lock.unlock();  //釋放鎖
    }
 
    public static void main(String[] args) {
        ReentrantLockTest1 r1 = new ReentrantLockTest1();
        new Thread(r1::m1).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(r1::m2).start();
    }
}

注意：使用reentrantLock必須要手動釋放鎖，使用syn鎖定的話如果遇到異常，jvm會自動釋放鎖，但Lock必須手動釋放鎖，因此常在finally中進行鎖的釋放；

4.2 ReentrantLock可以進行嘗試鎖定tryLock（）

public class ReentrantLock3 {
    Lock lock = new ReentrantLock();
    void m1(){
        try{
            lock.lock();
            for(int i=0; i<10;i++){
                TimeUnit.SECONDS.sleep(1);
                System.out.println(i);
            }
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    /**
     * 使用trylock進行嘗試鎖定,不管鎖定與否，方法都將繼續執行
     * 可以根據tryLock返回值來判斷是否鎖定
     * 也可以指定tryLock的時間，由於tryLock（time）拋出異常，所以要注意tryLock的處理
     * 必須放到finally中
     */
    void m2(){
        /*
        //第一種方式:
        boolean locked = lock.tryLock();
        //不管拿沒拿到鎖都將執行
        System.out.println("m2..."+locked);
        if(locked){
            lock.unlock();
        }
        */
        //第二種方式：
        boolean locked = false;
        try{
            //嘗試等5秒
            locked = lock.tryLock(5,TimeUnit.SECONDS);
            System.out.println("m2..."+locked);
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            if(locked)
                lock.unlock();
        }
    }

    public static void main(String[] args){
        ReentrantLock3 r3 = new ReentrantLock3();
        new Thread(r3::m1).start();
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        new Thread(r3::m2).start();
    }
}

4.3 使用ReentrantLock還可以調用lockInterruptibly()方法，可以對線程interrupt方法做出響應

在一個線程等待的過程中可以被打斷

public class ReentrantLock4 {
    public static void main(String[] args){
        Lock lock = new ReentrantLock();
        Thread t1 = new Thread(()->{
            try{
                lock.lock();
                System.out.println("t1 start");
                TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
                System.out.println("t1 end");
            }catch(InterruptedException e){
                System.out.println("Interrupted!");
            }finally{
                lock.unlock();
            }
        });
        t1.start();

        Thread t2 = new Thread(()->{
            boolean locked = false;
            try {
                lock.lockInterruptibly();
                System.out.println("t2 start");
                TimeUnit.SECONDS.sleep(5);
                System.out.println("t2 end");
            }catch(InterruptedException e){
                System.out.println("interrupted");
            }finally{
                if(locked)
                    lock.unlock();
            }
        });
        t2.start();
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        t2.interrupt();
    }
}

4.4. ReentrantLock指定為公平鎖（誰等的時間長，誰得到鎖）

public class ReentrantLock5 extends  Thread{
    private static ReentrantLock lock = new ReentrantLock(true);//true表示公平鎖
    public void run(){
        for(int i=0; i<100; i++){
            lock.lock();
            try{
                System.out.println(Thread.currentThread().getName()+"獲得鎖");

            }finally{
                lock.unlock();
            }
        }
    }
    public static void main(String[] args){
        ReentrantLock5 r5 = new ReentrantLock5();
        Thread th1 = new Thread(r5);
        Thread th2 = new Thread(r5);
        th1.start();
        th2.start();
    }
}

4.5 面試題：寫一個固定容量的同步容器，有put和get方法，能夠支持2個生產者線程以及10個消費者線程的阻塞調用：

方法1：使用wait和notify/notifyAll來實現：

public class MyContainer1<T> {
    final private LinkedList<T> lists = new LinkedList<>();
    final private int MAX =10;
    private int count = 0;

    public synchronized void put(T t){
        while(lists.size()==MAX){
            try{
                this.wait();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
        lists.add(t);
        ++count;
        this.notifyAll();//通知消費者線程進行消費
    }
    public synchronized T get(){
        T t = null;
        //為什么用while? wait 99.9%情況下都是和while一起用的
        //
        while(lists.size()==0){
            try{
                this.wait();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
        t = lists.removeFirst();
        count--;
        this.notifyAll();
        return t;
    }

    public static void main(String[] args){
        MyContainer1<String> c = new MyContainer1<>();
        //啟動消費者線程
        for(int i=0; i<10; i++){
            new Thread(()->{
                for(int j=0; j<5; j++){
                    System.out.println(c.get());
                }
            },"c"+i).start();
        }
        try{
            TimeUnit.SECONDS.sleep(2);
        }catch(InterruptedException e){
            e.printStackTrace();
        }

        //啟動生產者線程
        for(int i=0;i<2;i++){
            new Thread(()->{
                for(int j =0;j<25;j++){
                    c.put(Thread.currentThread().getName()+" "+j);
                }
            },"p"+i).start();
        }
     }
}

方法2：使用

使用Lock和Condition的方式可以更加精確地指定哪些線程被喚醒

public class MyContainer2<T> {
    final private LinkedList<T> lists= new LinkedList<>();
    final private int MAX =20;
    private int count = 0;

    private Lock lock = new ReentrantLock();
    private Condition producer = lock.newCondition();
    private Condition consumer = lock.newCondition();

    public void put(T t){
        try{
            lock.lock();
            while(lists.size()==MAX){
                producer.await();
            }
            lists.add(t);
            ++count;
            consumer.signalAll();
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }

    public T get(){
        T t = null;
        try{
            lock.lock();
            while(lists.size()==0){
                consumer.await();
            }
            t=lists.removeFirst();
            count--;
            producer.signalAll();
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
        return t;
    }

    public static void main(String[] args){
        MyContainer2<String> c = new MyContainer2();

        for(int i=0; i<10; i++){
            new Thread(()->{
                for(int j=0; j<5; j++){
                    System.out.println(c.get());
                }
            },"c"+i).start();
        }
        try{
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        //啟動生產者線程
        for(int i=0;i<2;i++){
            new Thread(()->{
                for(int j =0;j<25;j++){
                    c.put(Thread.currentThread().getName()+" "+j);
                }
            },"p"+i).start();
        }
    }
}

5. 線程局部變量 ThreadLocal

public class ThreadLocal1 {
    volatile static Person p = new Person();
    public static void main(String[] args){
        new Thread(()->{
            try{
                TimeUnit.SECONDS.sleep(2);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(p.name);
        }).start();

        new Thread(()->{
            try{
                TimeUnit.SECONDS.sleep(1);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            p.name = "lisi";
        }).start();
    }
}
class Person{
    String name  = "zhangsan";
}

結果為”lisi“

設定為線程局部變量：

public class ThreadLocal2 {
    static ThreadLocal<Person> tl = new ThreadLocal<>();
    public static void main(String[] args){
        new Thread(()->{
            try{
                TimeUnit.SECONDS.sleep(2);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(tl.get());
        }).start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(1);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }).start();
    }
    static class Person{
        String name = "zhangsan";
    }
}

結果為null。