多線程線程狀態?爲何使用線程池?如何建立線程池?如何解決線程安全?線程安全-可見性,線程安全-原子性,併發容器注意特色.併發工具類

時間 2021-01-04

標籤 java c++ 算法數組安全多線程併發 dom ide 工具欄目 Java 简体版

原文原文鏈接

　　　　　　　　　　　　　　　　　　　　　　　　　　重難點梳理

　　　　　　　　　　　　　　　　　　　　　　　　知識點梳理

　　　　　　　　　　　　　　　　　　　　　　　　學習目標

一、可以知道java中線程的相關狀態以及各個狀態之間的轉換過程java

二、可以理解什麼是線程池(概述，Executors方式建立線程池，ThreadPoolExecutor方式建立線程池，線程池原理說明)c++

三、可以瞭解volatile關鍵字的語義（特色）算法

四、可以知道什麼是原子性(原子性概述，常見原子類的使用，CAS算法)數組

五、可以掌握jdk中提供的線程併發工具類的使用（ConcurrentHashMap，CountDownLatch，Semaphore）安全

　　　　　　　　　　　　　　　　　　　　　　　　超詳細講義

==知識點==

1.線程狀態多線程

2.線程池併發

3.volatiledom

4.原子性ide

5.併發工具包工具

1. 線程狀態介紹【記憶】

(共3點)

1.線程狀態介紹

當線程被建立並啓動之後，它既不是一啓動就進入了執行狀態，也不是一直處於執行狀態。線程對象在不一樣的時期有不一樣的狀態,同一時刻線程只能存於一種狀態

2.各個狀態的轉換，以下圖所示：

3.Java中的線程存在哪幾種狀態呢？

Java中的線程狀態被定義在了java.lang.Thread.State枚舉類中，State枚舉類的源碼以下：

public class Thread {
    
    public enum State {
    
        /* 新建 */
        NEW , 

        /* 可運行狀態 */
        RUNNABLE , 

        /* 阻塞狀態 */
        BLOCKED , 

        /* 無限等待狀態 */
        WAITING , 

        /* 計時等待 */
        TIMED_WAITING , 

        /* 終止 */
        TERMINATED;
    
 }
    
    // 獲取當前線程的狀態
    public State getState() {
        return jdk.internal.misc.VM.toThreadState(threadStatus);
   }
    
}

經過源碼咱們能夠看到Java中的線程存在6種狀態，每種線程狀態的含義以下

線程狀態	具體含義
NEW	一個還沒有啓動的線程的狀態。也稱之爲初始狀態、開始狀態。線程剛被建立，可是並未啓動。還沒調用start方法。MyThread t = new MyThread()只有線程象，沒有線程特徵。
RUNNABLE	當咱們調用線程對象的start方法，那麼此時線程對象進入了RUNNABLE狀態。那麼此時纔是真正的在JVM進程中建立了一個線程，線程一經啓動並非當即獲得執行，線程的運行與否要聽令與CPU的調度，那麼咱們把這個中間狀態稱之爲可執行狀態(RUNNABLE)也就是說它具有執行的資格，可是並無真正的執行起來而是在等待CPU的度。
BLOCKED	當一個線程試圖獲取一個對象鎖，而該對象鎖被其餘的線程持有，則該線程進入Blocked狀態；當該線程持有鎖時，該線程將變成Runnable狀態。
WAITING	一個正在等待的線程的狀態。也稱之爲等待狀態。形成線程等待的緣由有兩種，分別是調用Object.wait()、join()方法。處於等待狀態的線程，正在等待其餘線程去執行一個特定的操做。例如：由於wait()而等待的線程正在等待另外一個線程去調用notify()或notifyAll()；一個由於join()而等待的線程正在等待另外一個線程結束。
TIMED_WAITING	一個在限定時間內等待的線程的狀態。也稱之爲限時等待狀態。形成線程限時等待狀態的緣由有三種，分別是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED	一個徹底運行完成的線程的狀態。也稱之爲終止狀態、結束狀態

2.線程池

2.1 線程池-基本原理【難點】

（共3點）

1.什麼是線程池？

存線程的容器就是線程池

2.線程池的原理？

==3.爲何要使用線程池？==

用少許的線程執行更多的任務，提升線程的利用率

2.2 線程池-Executors默認線程池【瞭解】

1.如何建立線程池？

使用Executors中所提供的靜態方法來建立線程池

static ExecutorService newCachedThreadPool() 建立一個默認的線程池 static ExecutorService newFixedThreadPool(int nThreads) 建立一個指定最多線程數量的線程池

2.如何把線程放到線程池中？（ExecutorServicer）

方法	說明
Future<?> submit(Runnable task	提交一個可運行的任務執行，並返回一個表示該任務的將來。

3.如何關閉線程池？

方法	說明
void shutdown()	關閉線程池，先前提交的任務將被執行，但不會接受任何新任務

代碼實現 :

package com.itheima.mythreadpool;


//static ExecutorService newCachedThreadPool•()   建立一個默認的線程池
//static newFixedThreadPool•(int nThreads)   建立一個指定最多線程數量的線程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException {

        //1,建立一個默認的線程池對象.池子中默認是空的.默認最多能夠容納int類型的最大值.
        ExecutorService executorService = Executors.newCachedThreadPool();
        //Executors --- 能夠幫助咱們建立線程池對象
        //ExecutorService --- 能夠幫助咱們控制線程池

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在執行了");
       });

        //Thread.sleep(2000);

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在執行了");
       });

        executorService.shutdown();//關閉後不能再提交了，所以後面的代碼會報錯
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在執行了");
       });
   }
}

2.3 線程池-Executors建立指定上限的線程池【瞭解】

使用Executors中所提供的靜態方法來建立線程池

static ExecutorService newFixedThreadPool(int nThreads) : 建立一個指定最多線程數量的線程池

代碼實現 :

package com.itheima.mythreadpool;

//static ExecutorService newFixedThreadPool•(int nThreads)
//建立一個指定最多線程數量的線程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class MyThreadPoolDemo2 {
    public static void main(String[] args) {
        //參數不是初始值而是最大值
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
        System.out.println(pool.getPoolSize());//0

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在執行了");
       });

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在執行了");
       });

        System.out.println(pool.getPoolSize());//2
//       executorService.shutdown();
   }
}

==若是線程執行完沒有返回值，將來的get方法將在成功完成後返回null；若是線程執行完有返回值，將來的get方法將在成功完成後返回線程執行完的返回值==

2.4 線程池-ThreadPoolExecutor 【重點】

建立線程池對象 :

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心線程數量,最大線程數量,空閒線程最大存活時間,任務隊列,建立線程工廠,任務的拒絕策略);

代碼實現 :

package com.itheima.mythreadpool;


import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo3 {
//     參數一：核心線程數量---正式員工                     --不能小於0--
//     參數二：最大線程數--- 餐廳最大員工數                 --不能小於0，最大數量>=核心線程數量--
//     參數三：空閒線程最大存活時間--- 臨時員工空閒多長時間被辭退(值)   --不能小於0--
//     參數四：時間單位 ---臨時員工空閒多長時間被辭退(單位)   --時間單位--
//     參數五：任務隊列 ---排隊的客戶                         --不能爲null--
//     參數六：建立線程工廠 ---從哪裏招人                     --不能爲null--
//     參數七：任務的拒絕策略 ---排隊的人過多，超出顧客請下次再來(拒絕服務)   --不能爲null--
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());

        pool.shutdown();
   }
}

2.5 線程池-參數詳解【難點】

package com.itheima.mythreadpool;


import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo4 {
//   參數一：核心線程數量
//   參數二：最大線程數
//   參數三：空閒線程最大存活時間
//   參數四：時間單位---TimeUnit
//   參數五：任務隊列 --- 讓任務在隊列中等着，等有線程空閒了，再從這個隊列中獲取任務並執行
//   參數六：建立線程工廠 --- 按照默認的方式建立線程對象
//   參數七：任務的拒絕策略 --- 1.什麼時拒絕？ 當線程池中沒有空閒線程，而且隊列已滿時
                              //2.如何拒絕？ 拒絕策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,
                5,
                2,TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 16; i++) {
            pool.submit(new MyRunnable());
       }

        pool.shutdown();
   }
}

2.拒絕策略

3.默認拒絕策略

package com.itheima.mythreadpool;


import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo4 {
//   參數一：核心線程數量
//   參數二：最大線程數
//   參數三：空閒線程最大存活時間
//   參數四：時間單位---TimeUnit
//   參數五：任務隊列 --- 讓任務在隊列中等着，等有線程空閒了，再從這個隊列中獲取任務並執行
//   參數六：建立線程工廠 --- 按照默認的方式建立線程對象
//   參數七：任務的拒絕策略 --- 1.什麼時拒絕？ 當同時須要被執行的任務 > 池子中最大的線程數量+隊列的容量
                              //2.如何拒絕？ 拒絕策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,
                5,
                2,TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 10; i++) {
            pool.submit(new MyRunnable());
       }

        pool.shutdown();
   }
}

2.6線程池-非默認任務拒絕策略【瞭解】

RejectedExecutionHandler是jdk提供的一個任務拒絕策略接口，它下面存在4個子類。

ThreadPoolExecutor.AbortPolicy:      丟棄任務並拋出RejectedExecutionException異常。是默認的策略。
ThreadPoolExecutor.DiscardPolicy：     丟棄任務，可是不拋出異常 這是不推薦的作法。
ThreadPoolExecutor.DiscardOldestPolicy：    拋棄隊列中等待最久的任務 而後把當前任務加入隊列中。
ThreadPoolExecutor.CallerRunsPolicy:        調用任務的run()方法繞過線程池直接執行。

注意：明確線程池最多可執行的任務數 = 隊列容量 + 最大線程數

案例演示2：演示ThreadPoolExecutor.DiscardPolicy任務處理策略

package com.itheima.mythreadpool;


import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo5 {
//   參數一：核心線程數量
//   參數二：最大線程數
//   參數三：空閒線程最大存活時間
//   參數四：時間單位---TimeUnit
//   參數五：任務隊列 --- 讓任務在隊列中等着，等有線程空閒了，再從這個隊列中獲取任務並執行
//   參數六：建立線程工廠 --- 按照默認的方式建立線程對象
//   參數七：任務的拒絕策略 --- 1.什麼時拒絕？ 當提交的任務 > 池子中最大的線程數量+隊列的容量
                              //2.如何拒絕？ 拒絕策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,
                2,
                2,TimeUnit.HOURS,
                new ArrayBlockingQueue<>(1),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());
        for (int i = 1; i < 5; i++) {
            int y=i;
            pool.submit(()->{
                System.out.println(Thread.currentThread().getName()+"---"+y);
           });
       }

        pool.shutdown();
   }
}

案例演示3：演示ThreadPoolExecutor.DiscardOldestPolicy任務處理策略

package com.itheima.mythreadpool;


import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo6 {
//   參數一：核心線程數量
//   參數二：最大線程數
//   參數三：空閒線程最大存活時間
//   參數四：時間單位---TimeUnit
//   參數五：任務隊列 --- 讓任務在隊列中等着，等有線程空閒了，再從這個隊列中獲取任務並執行
//   參數六：建立線程工廠 --- 按照默認的方式建立線程對象
//   參數七：任務的拒絕策略 --- 1.什麼時拒絕？ 當提交的任務 > 池子中最大的線程數量+隊列的容量
                              //2.如何拒絕？ 拒絕策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,
                2,
                2,TimeUnit.HOURS,
                new ArrayBlockingQueue<>(1),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 1; i <= 10; i++) {
            int y=i;
            pool.submit(()->{
                System.out.println(Thread.currentThread().getName()+"---"+y);
           });
       }

        pool.shutdown();
   }
}

案例演示4：演示ThreadPoolExecutor.CallerRunsPolicy任務處理策略

package com.itheima.mythreadpool;


import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo7 {
//   參數一：核心線程數量
//   參數二：最大線程數
//   參數三：空閒線程最大存活時間
//   參數四：時間單位---TimeUnit
//   參數五：任務隊列 --- 讓任務在隊列中等着，等有線程空閒了，再從這個隊列中獲取任務並執行
//   參數六：建立線程工廠 --- 按照默認的方式建立線程對象
//   參數七：任務的拒絕策略 --- 1.什麼時拒絕？ 當提交的任務 > 池子中最大的線程數量+隊列的容量
                              //2.如何拒絕？ 拒絕策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,
                2,
                2,TimeUnit.HOURS,
                new ArrayBlockingQueue<>(1),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 1; i <= 10; i++) {
            int y=i;
            pool.submit(()->{
                System.out.println(Thread.currentThread().getName()+"---"+y);
           });
       }

        pool.shutdown();
   }
}

3. volatile

3.1 volatile-問題【瞭解】

代碼分析 :

package com.itheima.myvolatile2;

public class Money {
    public static  int money = 100000;
}

package com.itheima.myvolatile2;

public class MyThread1 extends Thread {
    @Override
    public void run() {
        while (Money.money==100000) {
            
       }
        System.out.println("結婚基金已經不是十萬了");
   }
}

package com.itheima.myvolatile2;

public class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10);
       } catch (InterruptedException e) {
            e.printStackTrace();
       }
        Money.money = 90000;
   }
}

程序問題 : 女孩雖然知道結婚基金是十萬，可是當基金的餘額發生變化的時候，女孩沒法知道最新的餘額。

3.2 volatile解決【重點】

1.volatile的特色：

每一次使用volatile關鍵字修飾的變量時，都會看一看內存中的最新值

代碼實現 : 使用volatile關鍵字解決

package com.itheima.myvolatile;
public class Money {
    public static volatile int money = 100000;
}

package com.itheima.myvolatile;

public class MyThread1 extends  Thread {
    @Override
    public void run() {
        while (true){
            if (Money.money<10000){
                System.out.println("結婚基金已經不是十萬了");
           }
       }
   }
}

package com.itheima.myvolatile;

public class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(100);
       } catch (Exception e) {
            e.printStackTrace();
       }
        Money.money=9000;
   }
}

package com.itheima.myvolatile;

public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("小路同窗");
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("小皮同窗");
        t2.start();
    }
}

3.3 synchronized解決【重點】

1.synchronized線程執行互斥代碼的過程:

1 ，線程得到鎖

2 ，清空變量副本

3 ，拷貝共享變量最新的值到變量副本中

4 ，執行代碼

5 ，將修改後變量副本中的值賦值給共享數據

6 ，釋放鎖

代碼實現 :

package com.itheima.myvolatile;
public class Money {
    public static volatile int money = 100000;
}

package com.itheima.myvolatile2;

public class Money {
    public static Object lock = new Object();
    public static volatile int money = 100000;
}

package com.itheima.myvolatile2;

public class MyThread1 extends  Thread {
    @Override
    public void run() {
        while(true){

                if(Money.money != 100000){
                    System.out.println("結婚基金已經不是十萬了");
                    break;
                }
            }

    }
}

package com.itheima.myvolatile2;

public class MyThread2 extends Thread {
    @Override
    public void run() {
        synchronized (Money.lock) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            Money.money = 90000;
        }
    }
}

4.原子性

4.1 原子性【瞭解】

（共2點）

1.什麼是原子性

所謂的原子性就是完成功能的全部操做要麼都執行，要麼都不執行

代碼實現 :

package com.itheima.threadatom;

public class MyAtomThread implements Runnable {
    private volatile int count = 0; //送冰淇淋的數量

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,從共享數據中讀取數據到本線程棧中.
            //2,修改本線程棧中變量副本的值
            //3,會把本線程棧中變量副本的值賦值給共享數據.
            count++;
            System.out.println("已經送了" + count + "個冰淇淋");
        }
    }
}


package com.itheima.threadatom;

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}

代碼總結 : count++ 不是一個原子性操做, 他在執行的過程當中,有可能被其餘線程打斷

4.2 volatile關鍵字不能保證原子性【瞭解】

1.volatile關鍵字不能保證原子性的緣由分析

2.java中如何保證原子性操做？

使用鎖
利用原子類(後面講解)

package com.itheima.threadatom2;

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}

package com.itheima.threadatom2;

public class MyAtomThread implements Runnable {
    private volatile int count = 0; //送冰淇淋的數量
    private Object lock = new Object();

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,從共享數據中讀取數據到本線程棧中.
            //2,修改本線程棧中變量副本的值
            //3,會把本線程棧中變量副本的值賦值給共享數據.
            synchronized (lock) {
                count++;
                System.out.println("已經送了" + count + "個冰淇淋");
            }
        }
    }
}

4.3 原子性_AtomicInteger 【重點】

1.什麼是原子類?

原子類提供了一種用法簡單，性能高效，線程安全地更新一個變量的方式

2.如何使用原子的方式更新基本類型？

使用原子的方式更新基本類型,atomic包提供了：

AtomicInteger：原子更新整型

3.AtomicInteger的經常使用方法：

方法	說明
public AtomicInteger()	初始化一個默認值爲0的原子型Integer
public AtomicInteger(int initialValue)	初始化一個指定值的原子型Integer
int get()	獲取值
int getAndIncrement()	以原子方式將當前值加1，注意，這裏返回的是自增前的值。
int incrementAndGet()	以原子方式將當前值加1，注意，這裏返回的是自增後的值。
int addAndGet(int data)	以原子方式將輸入的數值與實例中的值（AtomicInteger裏的value）相加，並返回結果
int getAndSet(int value)	以原子方式設置爲newValue的值，並返回舊值

代碼實現 :

package com.itheima.threadatom3;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo1 {
//    public AtomicInteger()：	               初始化一個默認值爲0的原子型Integer
//    public AtomicInteger(int initialValue)： 初始化一個指定值的原子型Integer
    public static void main(String[] args) {
        AtomicInteger ac = new AtomicInteger();
        System.out.println(ac);

        AtomicInteger ac2 = new AtomicInteger(10);
        System.out.println(ac2);
    }

}

package com.itheima.threadatom3;

import java.lang.reflect.Field;
import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo2 {
//    int get():   		         獲取值
//    int getAndIncrement():     以原子方式將當前值加1，注意，這裏返回的是自增前的值。
//    int incrementAndGet():     以原子方式將當前值加1，注意，這裏返回的是自增後的值。
//    int addAndGet(int data):	 以原子方式將參數與對象中的值相加，並返回結果。
//    int getAndSet(int value):  以原子方式設置爲newValue的值，並返回舊值。
    public static void main(String[] args) {
//        AtomicInteger ac1 = new AtomicInteger(10);
//        System.out.println(ac1.get());

//        AtomicInteger ac2 = new AtomicInteger(10);
//        int andIncrement = ac2.getAndIncrement();
//        System.out.println(andIncrement);
//        System.out.println(ac2.get());

//        AtomicInteger ac3 = new AtomicInteger(10);
//        int i = ac3.incrementAndGet();
//        System.out.println(i);//自增後的值
//        System.out.println(ac3.get());

//        AtomicInteger ac4 = new AtomicInteger(10);
//        int i = ac4.addAndGet(20);
//        System.out.println(i);
//        System.out.println(ac4.get());

        AtomicInteger ac5 = new AtomicInteger(100);
        int andSet = ac5.getAndSet(20);
        System.out.println(andSet);
        System.out.println(ac5.get());


    }

}

4.4 AtomicInteger-內存解析【難點】

AtomicInteger原理 : 自旋鎖 + CAS 算法

package com.itheima.threadatom4;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomThread implements Runnable {
    //private volatile int count = 0; //送冰淇淋的數量
    //private Object lock = new Object();
    AtomicInteger ac = new AtomicInteger(0);

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,從共享數據中讀取數據到本線程棧中.
            //2,修改本線程棧中變量副本的值
            //3,會把本線程棧中變量副本的值賦值給共享數據.
            //synchronized (lock) {
//                count++;
//                ac++;
            int count = ac.incrementAndGet();
            System.out.println("已經送了" + count + "個冰淇淋");
           // }
        }
    }
}

package com.itheima.threadatom4;

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}

4.5 AtomicInteger-源碼解析【瞭解】

//當前主內存中的地址
private volatile int value;
//先自增，而後獲取自增後的結果
public final int incrementAndGet() {
        //+ 1 自增後的結果
        //this 就表示當前的atomicInteger（值）
        //1    自增一次
        return U.getAndAddInt(this, VALUE, 1) + 1;
}

public final int getAndAddInt(Object o, long offset, int delta) {
        //v 舊值
        int v;
        //自旋的過程
        do {
            //不斷的獲取舊值
            v = getIntVolatile(o, offset);
            //若是這個方法的返回值爲false，那麼繼續自旋
            //若是這個方法的返回值爲true，那麼自旋結束
            //o 表示的就是內存值
            //v 舊值
            //v + delta 修改後的值
        } while (!weakCompareAndSetInt(o, offset, v, v + delta));
            //做用：比較內存中的值，舊值是否相等，若是相等就把修改後的值寫到內存中，返回true。表示修改爲功。
            //                                 若是不相等，沒法把修改後的值寫到內存中，返回false。表示修改失敗。
            //若是修改失敗，那麼繼續自旋。
        return v;
}

4.6 悲觀鎖和樂觀鎖【瞭解】

synchronized和CAS的區別 :

相同點：在多線程狀況下，均可以保證共享數據的安全性。

不一樣點：

synchronized老是從最壞的角度出發，認爲每次獲取數據的時候，別人都有可能修改。因此在每次操做共享數據以前，都會上鎖。（悲觀鎖）

cas是從樂觀的角度出發，假設每次獲取數據別人都不會修改，因此不會上鎖。只不過在修改共享數據的時候，會檢查一下，別人有沒有修改過這個數據。

若是別人修改過，那麼我再次獲取如今最新的值。

若是別人沒有修改過，那麼我如今直接修改共享數據的值.(樂觀鎖）

jdk1.6 synchronized(偏向鎖，輕量鎖(cas),重量級鎖(悲觀鎖)) ，cas

5. 併發工具包

5.1 併發容器-Hashtable 【重點】

（共3點)

1.爲何要使用Hashtable

在集合類中HashMap是比較經常使用的集合對象，可是HashMap是線程不安全的(多線程環境下可能會存在問題)。爲了保證數據的安全性咱們可使用Hashtable，可是Hashtable的效率低下。

2.Hashtable的原理?

3.HashTable的特色?

1.Hashtable採起悲觀鎖synchronized的形式保證數據的安全性

2.只要有線程訪問，會將整張表所有鎖起來,因此Hashtable效率低下

代碼實現 :

package com.itheima.mymap;

import java.util.HashMap;
import java.util.Hashtable;

public class MyHashtableDemo {
    public static void main(String[] args) throws InterruptedException {
        Hashtable<String, String> hm = new Hashtable<>();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });


        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });

        t1.start();
        t2.start();

        System.out.println("----------------------------");
        //爲了t1和t2能把數據所有添加完畢
        Thread.sleep(1000);

        //0-0 1-1 ..... 50- 50

        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50


    }
}

5.2 併發容器-ConcurrentHashMap基本使用【重點】

（共3點）

1.爲何要使用ConcurrentHashMap?

爲了保證數據的安全性也要考慮效率的狀況下,JDK1.5之後所提供ConcurrentHashMap。

2.什麼是ConcurrentHashMap？

體系結構 :

3.三種Map結構的對比

1 ，HashMap是線程不安全的。多線程環境下會有數據安全問題

2 ，Hashtable是線程安全的，可是會將整張表鎖起來，效率低下

3，ConcurrentHashMap也是線程安全的，效率較高。在JDK7和JDK8中，底層原理不同。

代碼實現 :

package com.itheima.mymap;

import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;

public class MyConcurrentHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, String> hm = new ConcurrentHashMap<>();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });


        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });

        t1.start();
        t2.start();

        System.out.println("----------------------------");
        //爲了t1和t2能把數據所有添加完畢
        Thread.sleep(1000);

        //0-0 1-1 ..... 50- 50

        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50


    }
}

5.3 併發工具類-ConcurrentHashMap1.7原理【瞭解】（視頻19 12‘’）

3.4 併發容器-ConcurrentHashMap1.8原理【瞭解】（視頻20 10‘’）

總結 :

1，若是使用空參構造建立ConcurrentHashMap對象，則什麼事情都不作。在第一次添加元素的時候建立哈希表

2，計算當前元素應存入的索引。

3，若是該索引位置爲null，則利用cas算法，將本結點添加到數組中。

4，若是該索引位置不爲null，則利用volatile關鍵字得到當前位置最新的結點地址，掛在他下面，變成鏈表。

5，當鏈表的長度大於等於8時，自動轉換成紅黑樹6，以鏈表或者紅黑樹頭結點爲鎖對象，配合悲觀鎖保證多線程操做集合時數據的安全性

5.5 併發工具類-CountDownLatch【重點】(視頻21 12‘’)

1.CountDownLatch的應用場景

讓某一條線程等待其餘線程執行完畢以後再執行

2.CountDownLatch類中經常使用的方法 :

方法	解釋
public CountDownLatch(int count)	參數傳遞線程數，表示等待線程數量。並定義一個計數器
public void await()	讓線程等待,當計數器爲0時，會喚醒等待的線程
public void countDown()	當前線程執行完畢時，會將計數器-1

3.原理

CountDownLatch是經過一個計數器來實現的，計數器的初始值爲須要等待線程的數量。

eg：CountDownLatch c = new CountDownLatch(10); // 等待線程的數量爲10

線程調用CountDownLatch的await()方法會阻塞當前線程(即:主線程在閉鎖上等待)，直到計數器的值爲0。
當一個工做線程完成了本身的任務後，調用CountDownLatch的countDown()方法，計數器的值就會減1。
當計數器值爲0時，說明全部的工做線程都執行完了，此時，在閉鎖上等待的主線程就能夠恢復執行任務

代碼實現 :

package com.itheima.mycountdownlatch;

import java.util.concurrent.CountDownLatch;

public class ChileThread1 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread1(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        //1.吃餃子
        for (int i = 1; i <= 10; i++) {
            System.out.println(getName() + "在吃第" + i + "個餃子");
        }
        //2.吃完說一聲
        //每一次countDown方法的時候，就讓計數器-1
        countDownLatch.countDown();
    }
}

package com.itheima.mycountdownlatch;

import java.util.concurrent.CountDownLatch;

public class ChileThread2 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread2(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃餃子
        for (int i = 1; i <= 15; i++) {
            System.out.println(getName() + "在吃第" + i + "個餃子");
        }
        //2.吃完說一聲
        //每一次countDown方法的時候，就讓計數器-1
        countDownLatch.countDown();
    }
}

package com.itheima.mycountdownlatch;

import java.util.concurrent.CountDownLatch;

public class ChileThread3 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread3(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃餃子
        for (int i = 1; i <= 20; i++) {
            System.out.println(getName() + "在吃第" + i + "個餃子");
        }
        //2.吃完說一聲
        //每一次countDown方法的時候，就讓計數器-1
        countDownLatch.countDown();
    }
}

package com.itheima.mycountdownlatch;

import java.util.concurrent.CountDownLatch;

public class MotherThread extends Thread {
    private CountDownLatch countDownLatch;
    public MotherThread(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        //1.等待
        try {
            //當計數器變成0的時候，會自動喚醒這裏等待的線程。
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //2.收拾碗筷
        System.out.println("媽媽在收拾碗筷");
    }
}

package com.itheima.mycountdownlatch;

import java.util.concurrent.CountDownLatch;

public class MyCountDownLatchDemo {
    public static void main(String[] args) {
        //1.建立CountDownLatch的對象，須要傳遞給四個線程。
        //在底層就定義了一個計數器，此時計數器的值就是3
        CountDownLatch countDownLatch = new CountDownLatch(3);
        //2.建立四個線程對象並開啓他們。
        MotherThread motherThread = new MotherThread(countDownLatch);
        motherThread.start();

        ChileThread1 t1 = new ChileThread1(countDownLatch);
        t1.setName("小明");

        ChileThread2 t2 = new ChileThread2(countDownLatch);
        t2.setName("小紅");

        ChileThread3 t3 = new ChileThread3(countDownLatch);
        t3.setName("小剛");

        t1.start();
        t2.start();
        t3.start();
    }
}

5.6 併發工具類-Semaphore 【重點】

1.Semaphore類的應用場景？

能夠控制訪問特定資源的線程數量。

2.原理

Semaphore是經過一個計數器(記錄許可證的數量)來實現的，計數器的初始值爲須要等待線程的數量
eg：Semaphore s = new Semaphore(10); // 線程最大的併發數爲10
線程經過acquire()方法獲取許可證(計數器的值減1)，只有獲取到許可證才能夠繼續執行下去，不然阻塞當前線程
線程經過release()方法歸還許可證(計數器的值加1)

代碼實現 :

package com.itheima.mysemaphore;

import java.util.concurrent.Semaphore;

public class MyRunnable implements Runnable {
    //1.得到管理員對象，
    private Semaphore semaphore=new Semaphore(2) ;


    @Override
    public void run() {
        //2.得到通行證
        try {
            semaphore.acquire();
            //3.開始行駛
            System.out.println("得到了通行證開始行駛");
            Thread.sleep(2000);
            System.out.println("歸還通行證");
            //4.歸還通行證
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.itheima.mysemaphore;

public class MySemaphoreDemo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();

        for (int i = 0; i < 100; i++) {
            new Thread(mr).start();
        }
    }
}

　　　　　　　　　　　　　　　　　　　　　　　　擴展練習

題目1

請利用線程間通訊, 完成連續打印1-100的數字, 要求一條線程專門打印奇數,另一條專門用來打印偶數

要求:

1:數字打印必須是有序的,既1--100的順序不能亂;

2:必須使用多線程技術;

效果:

........................

參考答案:

類1:

package day14.No_1;

public class Num {
    public  static int num=1;
    public  static Object look=new Object() ;
}

類2:

package day14.No_1;

public class Ji implements Runnable {

    @Override
    public void run() {
        while (true) {
            synchronized (Num.look) {
                Num.look.notifyAll();
                if (Num.num % 2 == 0) {
                    try {
                        Num.look.wait();
                   } catch (InterruptedException e) {
                        e.printStackTrace();
                   }
               } else {
                    System.out.println("第一條線程打印奇數" + Num.num);
                    Num.num++;
                    if (Num.num == 100) {
                        return;
                   }
               }
           }
       }
   }
}

類3:

package day14.No_1;


public class Ou implements Runnable {

    @Override
    public void run() {
        synchronized (Num.look) {
            while (true) {
                synchronized (Num.look) {
                    Num.look.notifyAll();
                    if (Num.num%2 == 1) {
                        try {
                            Num.look.wait();
                       } catch (InterruptedException e) {
                            e.printStackTrace();
                       }
                   } else {
                        System.out.println("第二條線程打印偶數" + Num.num);
                        Num.num++;
                        if (Num.num == 101) {
                            return;
                       }
                   }
               }
           }
       }
   }
}

測試類:

package day14.No_1;

public class Test {
    public static void main(String[] args) {
        Ji j = new Ji();
        Ou o = new Ou();
        new Thread(j).start();
        new Thread(o).start();
   }
}

運行效果:

題目2

假如某班級有10人,早晨老師來到教室以後,須要等待10位學生都到齊了纔會開始上課,若是10位學生尚未到齊,老師須要一直等待;假如把老師和每個學生都當作是一個獨立的線程,請使用代碼模擬這個老師上課的場景;

要求:

1:老師上課以前,打印老師準備就緒,等全部學生到齊以後,老師打印開始講課;

2:只有10個學生都到了,老師才能夠上課;

效果:

參考答案:

學生類:

package day14.No_2;

import java.util.concurrent.CountDownLatch;

public class Student implements Runnable {
    private CountDownLatch countDownLatch;

    public Student(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
   }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "到了");
        countDownLatch.countDown();
   }
}

教師類:

package day14.No_2;

import java.util.concurrent.CountDownLatch;

public class Teacher implements Runnable {
    private CountDownLatch countDownLatch;

    public Teacher(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
   }

    @Override
    public void run() {
        System.out.println("準備講課");
        try {
            countDownLatch.await();
            System.out.println("開始上課");
       } catch (InterruptedException e) {
            e.printStackTrace();
       }

   }
}

測試類:

package day14.No_2;

import java.util.concurrent.CountDownLatch;

public class Test {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(10);
        Teacher teachertast = new Teacher(countDownLatch);
        Student studenttast = new Student(countDownLatch);
        for (int i = 1; i <= 10; i++) {
            new Thread(studenttast, "學生" + i).start();
       }
        new Thread(teachertast).start();

   }
}

運行效果:

題目3[業務比較複雜,有難度呦]

假如如今有一輛公交車,車上有兩個乘務員,一個專門負責讓乘客上車,並提示目前車上的人數,另外一個乘務員專門負責乘客下車,並提示乘客下車後,目前車上的人數,請使用代碼模擬這個場景;

要求:

1:公交車最多乘坐30位乘客,若是超過30人,則上車的乘務員再也不安排乘客上車,會一直等待,直到車上有空位子再安排乘客上車;

2:若是車上乘客數量爲0了,則再也不乘客下車,直到車上有乘客,再繼續安排乘客下車;

3:每次上下車的人數採用隨機數的方式表示上車的人數和下車的人數,且上車時,1次最多上當前最大空餘座位數,最少是1人,下車時,1次最多下當前車上總乘客數,最少是1人;

效果:

參考答案:

類1:

package day14.No_3;

public class Chengwu {
    public static int count = 30;
    public static Object lock = new Object();
}

類2:

package day14.No_3;

import java.util.Random;

public class GetOff implements Runnable {
    @Override
    public void run() {
        while (true) {
            synchronized (Chengwu.lock) {
                if (Chengwu.count <= 0) {
                    try {
                        Chengwu.lock.wait();
                   } catch (InterruptedException e) {
                        e.printStackTrace();
                   }
               } else {
                    Random random = new Random();
                    int num = random.nextInt(Chengwu.count) + 1;
                    Chengwu.count -= num;
                    System.out.println("下去了" + num + "車上剩餘" + Chengwu.count + "人");
                    Chengwu.lock.notifyAll();
               }
           }
       }
   }
}

類3:

package day14.No_3;

import java.util.Random;

public class GetOn implements Runnable {
    @Override
    public void run() {
        while (true) {
            synchronized (Chengwu.lock) {
                if (Chengwu.count >= 30) {
                    try {
                        Chengwu.lock.wait();
                   } catch (InterruptedException e) {
                        e.printStackTrace();
                   }
               } else {
                    Random random = new Random();
                    int num = random.nextInt(30 - Chengwu.count) + 1;
                    Chengwu.count += num;
                    System.out.println("上去了" + num + "人,還剩下" + Chengwu.count);
                    Chengwu.lock.notifyAll();
               }
           }
       }
   }
}

測試類:

package day14.No_3;

public class Test {
    public static void main(String[] args) {
        GetOn getOn = new GetOn();
        GetOff getOff = new GetOff();
        Thread t1 = new Thread(getOn);
        Thread t2 = new Thread(getOff);
        t1.start();
        t2.start();
   }
}