091_多線程（二）

時間  2020-12-04
標籤 java 安全 多線程 併發 ide 工具 性能 測試 this 線程 欄目 Java 简体版
原文   原文鏈接

目錄

https://www.bilibili.com/video/BV1V4411p7EF/

線程同步機制

  1. 併發：同一個對象被多個線程同時操做。
  2. 處理多線程問題時，多個線程訪問同一個對象，而且某些線程還想修改這個對象，這時候咱們就須要線程同步。
  3. 線程同步其實就是一種等待機制，多個須要同時訪問此對象的線程進入這個對象的等待池造成隊列，等待前面的線程使用完畢，下一個線程再使用。
  4. 因爲同一進程的多個線程共享同一塊存儲空間，在帶來方便的同時，也帶來了訪問衝突問題，爲了保證數據在方法中被訪問時的正確性，在訪問時加入 鎖機制synchronized ,當一個線程得到對象的排它鎖，獨佔資源，其餘線程必須等待，使用後釋放鎖便可。存在如下問題：
    1. 一個線程持有鎖會致使其餘全部須要此鎖的線程掛起。
    2. 在多線程競爭下，加鎖，釋放鎖會致使比較多的上下文切換和調度延時，引發性能問題。
    3. 若是一個優先級高的線程等待一個優先級低的線程釋放鎖，會致使優先級倒置，引發性能問題。

不安全案例

package com.qing.sync;

/**
 * 不安全的買票
 * 線程不安全，有負數
 */
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket, "楊康").start();
        new Thread(buyTicket, "郭靖").start();
        new Thread(buyTicket, "黃蓉").start();
    }
}

class BuyTicket implements Runnable {
    //票
    private int ticketNums = 10;
    @Override
    public void run() {
        //買票
        while (ticketNums > 0) {
            buy();
        }
    }
    private void buy() {
        //判斷是否有票
        if (ticketNums <= 0) {
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "買到第" + ticketNums-- + "票");
    }
}
楊康買到第10票
郭靖買到第9票
黃蓉買到第8票
楊康買到第7票
黃蓉買到第6票
郭靖買到第5票
楊康買到第4票
郭靖買到第3票
黃蓉買到第2票
黃蓉買到第1票
楊康買到第0票
郭靖買到第-1票
package com.qing.sync;

import java.util.ArrayList;
import java.util.List;

/**
 * 線程不安全的集合
 */
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}
9996

同步方法和同步塊

  1. 因爲咱們能夠經過private關鍵字來保證數據對象只能被方法訪問，因此咱們只須要針對方法提出一套機制，這套機制就是synchronized關鍵字，它包括兩種用法：
    1. synchronized方法。
    2. synchronized塊。
  2. synchronized方法控制對「對象」的訪問，每一個對象對應一把鎖，每一個synchronized方法都必須得到調用該方法的對象的鎖才能執行，不然線程會阻塞，方法一旦執行，就獨佔該鎖，直到該方法返回才釋放鎖，後面被阻塞的線程才能得到這個鎖，繼續執行。
  3. synchronized方法的缺陷：若將一個大的方法申明爲synchronized將會影響效率。
  4. 同步塊：synchronized(obj){}
  5. obj稱之爲同步監視器。
    1. obj能夠是任何對象，可是推薦使用共享資源做爲同步監視器。
    2. 同步方法中無需指定同步監視器，由於同步方法的同步監視器就是this，就是這個對象自己，或者是class。
  6. 同步監視器的執行過程：
    1. 第一個線程訪問，鎖定同步監視器，執行其中代碼。
    2. 第二個線程訪問，發現同步監視器被鎖定，沒法訪問。
    3. 第一個線程訪問完畢，解鎖同步監視器。
    4. 第二個線程訪問，發現同步監視器沒有鎖，而後鎖定並訪問。
  7. 同步塊鎖的對象是變化的量。
private synchronized void buy() {
        //判斷是否有票
        if (ticketNums <= 0) {
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "買到第" + ticketNums-- + "票");
    }
package com.qing.sync;

import java.util.ArrayList;
import java.util.List;

/**
 * 線程不安全的集合
 */
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}
10000

JUC併發安全 CopyOnWriteArrayList

package com.qing.sync;

import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 測試JUC安全類型的集合
 */
public class TestJuc {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 30000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}
30000

死鎖

  1. 多個線程各自佔有一些共享資源，而且互相等待其餘線程佔有的資源才能運行，而致使兩個或者多個線程都在等待對方釋放資源，都中止執行的情形。
  2. 某一個同步塊同時擁有「兩個以上對象的鎖」時，就可能發生「死鎖」的問題。
package com.qing.sync;

/**
 * 死鎖：多個線程互相持有對方須要的資源，而後造成僵持。
 */
public class DeadLock {
    public static void main(String[] args) {
        Makeup t1 = new Makeup(0,"灰姑娘");
        Makeup t2 = new Makeup(1,"白雪公主");
        t1.start();
        t2.start();
    }
}

//口紅
class Lipstick {

}
//鏡子
class Mirror {

}

class Makeup extends Thread {
    //須要的資源只有一份，用static來保證只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//選擇
    String girlName;//用化妝品的人

    public Makeup(int choice,String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妝
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妝，互相持有對方的鎖，就是須要拿到對方的資源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {//得到口紅的鎖
                System.out.println(this.girlName + "得到口紅的鎖");
                Thread.sleep(1000);
                synchronized (mirror) {//一秒鐘後得到鏡子的鎖
                    System.out.println(this.girlName + "得到鏡子的鎖");
                }
            }
        } else {
            synchronized (mirror) {//得到鏡子的鎖
                System.out.println(this.girlName + "得到鏡子的鎖");
                Thread.sleep(1000);
                synchronized (lipstick) {//一秒鐘後得到口紅的鎖
                    System.out.println(this.girlName + "得到口紅的鎖");
                }
            }
        }
    }
}
灰姑娘得到口紅的鎖
白雪公主得到鏡子的鎖

死鎖避免方法

  1. 產生死鎖的四個必要條件：
    1. 互斥條件：一個資源每次只能被一個線程使用。
    2. 請求與保持條件：一個進程因請求資源而阻塞時，對已得到的資源保持不放。
    3. 不剝奪條件：進程已得到的資源，在未使用完以前，不能強行剝奪。
    4. 循環等待條件：若干進程之間造成一種頭尾相接的循環等待資源關係。
  2. 上面列出了死鎖的四個必要條件，只要破除其中的任意一個或多個條件就能夠避免死鎖發生。

Lock（鎖）

  1. 從JDK5.0開始，Java提供了更強大的線程同步機制——經過顯式定義同步鎖對象來實現同步。同步鎖使用Lock對象充當。
  2. java.util.concurrent.locks.Lock接口是控制多個線程對共享資源進行訪問的工具。鎖提供了對共享資源的獨佔訪問，每次只能有一個線程對Lock對象加鎖，線程開始訪問共享資源以前應先得到Lock對象。
  3. ReentrantLock類實現了Lock，它擁有與synchronized相同的併發性和內存語義，在實現線程安全的控制中，比較經常使用的是ReentrantLock，能夠顯示加鎖、釋放鎖。
//定義Lock鎖
private final ReentrantLock lock = new ReentrantLock();

public void test() {
    try {
        lock.lock();//加鎖
        //保證線程安全的代碼        
    } finally {
        lock.unlock();//解鎖
    }
}
package com.qing.sync;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 測試Lock鎖
 */
public class TestLock {
    public static void main(String[] args) {
        Lock2 lock2 = new Lock2();

        new Thread(lock2).start();
        new Thread(lock2).start();
        new Thread(lock2).start();
    }
}

class Lock2 implements Runnable {

    int ticketNums = 10;

    //定義Lock鎖
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();//加鎖
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                } else {
                    break;
                }
            } finally {
                lock.unlock();//解鎖
            }
        }
    }
}
10
9
8
7
6
5
4
3
2
1

synchronized與Lock的對比

  1. Lock是顯式鎖（手動開啓和關閉鎖，別忘記關閉鎖）；synchronized是隱式鎖，出了做用域自動釋放。
  2. Lock只有代碼塊鎖，synchronized有代碼塊鎖和方法鎖。
  3. 使用Lock鎖，JVM將花費較少的時間來調度線程，性能更好，而且具備更好的擴展性（提供更多的子類）。
  4. 優先使用順序：Lock>同步代碼塊（已經進入了方法體，分配了相應資源）>同步方法（在方法體以外）。

線程協做：生產者消費者模式

線程通訊

  1. Java提供了幾個方法解決線程之間的通訊問題。

image.png

  1. 幾個方法均是Object類的方法，都只能在同步方法或者同步代碼塊中使用，不然會拋出異常IllegalMonitorStateException。

管程法

  1. 生產者：負責生產數據的模塊（多是方法，對象，線程，進程）。
  2. 消費者：負責處理數據的模塊（多是方法，對象，線程，進程）。
  3. 緩衝區：消費者不能直接使用生產者的數據，他們之間有個「緩衝區」。
  4. 生產者將生產的數據放入緩衝區，消費者從緩衝區拿出數據。

image.png

package com.qing.sync;

/**
 * 測試管程法：生產者消費者模型-->利用緩衝區解決
 * 生產者，消費者，產品，緩衝區
 */
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Producer(container).start();
        new Consumer(container).start();
    }
}

//生產者
class Producer extends Thread {
    SynContainer container;

    public Producer(SynContainer container) {
        this.container = container;
    }
    //生產
    @Override
    public void run() {
        for (int i = 1; i < 20; i++) {
            container.push(new Chicken(i));
            System.out.println("生產了" + i + "號雞");
        }
    }
}
//消費者
class Consumer extends Thread {
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }
    //消費
    @Override
    public void run() {
        for (int i = 1; i < 20; i++) {
            System.out.println("消費了" + container.pop().id + "號雞");
        }
    }
}
//產品
class Chicken {
    int id;//產品編號

    public Chicken(int id) {
        this.id = id;
    }
}
//緩衝區
class SynContainer {
    //須要一個容器大小
    Chicken[] chickens = new Chicken[5];
    //容器計數器
    int count = 0;

    //生產者放入產品
    public synchronized void push(Chicken chicken) {
        //若是容器滿了，就須要等待消費者消費
        if (count == chickens.length) {
            //生產者等待
            try {
                System.out.println("push-->wait");
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //若是容器沒有滿，就放入產品
        chickens[count] = chicken;
        count++;
        //通知消費者消費
        System.out.println("push-->notifyAll");
        this.notifyAll();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //消費者消費產品
    public synchronized Chicken pop() {
        //若是容器空了，就須要等待生產者放入產品
        if (count == 0) {
            //消費者等待
            try {
                System.out.println("pop-->wait");
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //若是容器沒有空，就消費產品
        count--;
        Chicken chicken = chickens[count];
        //通知生產者生產
        System.out.println("pop-->notifyAll");
        this.notifyAll();
        return chicken;
    }
}
pop-->wait
push-->notifyAll
生產了1號雞
push-->notifyAll
pop-->notifyAll
生產了2號雞
push-->notifyAll
消費了2號雞
pop-->notifyAll
生產了3號雞
消費了3號雞
push-->notifyAll
pop-->notifyAll
生產了4號雞
消費了4號雞
push-->notifyAll
生產了5號雞
pop-->notifyAll
消費了5號雞
push-->notifyAll
pop-->notifyAll
生產了6號雞
消費了6號雞
push-->notifyAll
pop-->notifyAll
消費了7號雞
pop-->notifyAll
生產了7號雞
消費了1號雞
push-->notifyAll
pop-->notifyAll
消費了8號雞
pop-->wait
生產了8號雞
push-->notifyAll
pop-->notifyAll
生產了9號雞
消費了9號雞
push-->notifyAll
pop-->notifyAll
生產了10號雞
push-->notifyAll
消費了10號雞
pop-->notifyAll
消費了11號雞
pop-->wait
生產了11號雞
push-->notifyAll
pop-->notifyAll
生產了12號雞
消費了12號雞
push-->notifyAll
pop-->notifyAll
生產了13號雞
消費了13號雞
push-->notifyAll
pop-->notifyAll
生產了14號雞
push-->notifyAll
消費了14號雞
pop-->notifyAll
消費了15號雞
pop-->wait
生產了15號雞
push-->notifyAll
pop-->notifyAll
生產了16號雞
消費了16號雞
push-->notifyAll
pop-->notifyAll
消費了17號雞
pop-->wait
生產了17號雞
push-->notifyAll
pop-->notifyAll
生產了18號雞
push-->notifyAll
消費了18號雞
生產了19號雞
pop-->notifyAll
消費了19號雞

信號燈法

package com.qing.sync;

/**
 * 測試信號燈法：生產者消費者模型--》標誌位解決
 */
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();

        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生產者-->演員
class Player extends Thread {
    TV tv;

    public Player(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (i%2 == 0) {
                this.tv.play("天上");
            } else {
                this.tv.play("人間");
            }
        }
    }
}
//消費者-->觀衆
class Watcher extends Thread {
    TV tv;

    public Watcher(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            this.tv.watch();
        }
    }
}
//產品-->節目
class TV {
    //演員表演，觀衆等待 T
    //觀衆觀看，演員等待 F
    String voice;//表演的節目
    boolean flag = true;

    //表演
    public synchronized void play(String voice) {
        if (!flag) {
            try {
                System.out.println("play-->wait");
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演員表演:" + voice);
        //通知觀衆觀看
        System.out.println("play-->notifyAll");
        this.notifyAll();
        this.voice = voice;
        this.flag = !this.flag;
    }
    //觀看
    public synchronized void watch() {
        if (flag) {
            try {
                System.out.println("watch-->wait");
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("觀衆觀看：" + voice);
        //通知演員表演
        System.out.println("watch-->notifyAll");
        this.notifyAll();
        this.voice = voice;
        this.flag = !this.flag;
    }
}
演員表演:天上
play-->notifyAll
play-->wait
觀衆觀看：天上
watch-->notifyAll
watch-->wait
演員表演:人間
play-->notifyAll
play-->wait
觀衆觀看：人間
watch-->notifyAll
watch-->wait
演員表演:天上
play-->notifyAll
play-->wait
觀衆觀看：天上
watch-->notifyAll
watch-->wait
演員表演:人間
play-->notifyAll
play-->wait
觀衆觀看：人間
watch-->notifyAll
watch-->wait
演員表演:天上
play-->notifyAll
play-->wait
觀衆觀看：天上
watch-->notifyAll
watch-->wait
演員表演:人間
play-->notifyAll
play-->wait
觀衆觀看：人間
watch-->notifyAll
watch-->wait
演員表演:天上
play-->notifyAll
play-->wait
觀衆觀看：天上
watch-->notifyAll
watch-->wait
演員表演:人間
play-->notifyAll
play-->wait
觀衆觀看：人間
watch-->notifyAll
watch-->wait
演員表演:天上
play-->notifyAll
play-->wait
觀衆觀看：天上
watch-->notifyAll
watch-->wait
演員表演:人間
play-->notifyAll
觀衆觀看：人間
watch-->notifyAll

線程池

  1. 背景：常常建立和銷燬、使用量特別大的資源，好比並髮狀況下的線程，對性能影響很大。
  2. 思路：提早建立好多個線程，放入線程池中，使用時直接獲取，使用完放回池中。能夠避免頻繁的建立銷燬，實現重複利用。
  3. 好處：
    1. 提供響應速度（減小了建立新線程的時間）。
    2. 下降資源消耗（重複利用線程池中的線程，不須要每次都建立）。
    3. 便於線程管理
      1. corePoolSize：核心池的大小
      2. maximumPoolSize：最大線程數
      3. keepAliveTime：線程沒有任務時最多保持多長時間後會終止
  4. JDK5.0提供了線程池相關API：ExecutorService和Executors。
  5. ExecutorService：真正的線程池接口。常見子類ThreadPoolExecutor.
    1. void execute(Runnable command)：執行任務/命令，沒有返回值，通常用來執行Runnable.
    2. Future submit(Callable task)：執行任務，有返回值，通常用來執行Callable。
    3. void shutdown：關閉鏈接池。
  6. Executors：工具類、線程池的工廠類，用於建立並返回不一樣類型的線程池。
package com.qing.sync;

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

/**
 * 測試線程池
 */
public class TestPool {
    public static void main(String[] args) {
        //1.建立服務，建立線程池
        //參數：線程池大小
        ExecutorService service = Executors.newFixedThreadPool(5);

        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2.關閉鏈接
        service.shutdown();
    }
}

class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
pool-1-thread-1
pool-1-thread-2
pool-1-thread-4
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-5

總結

package com.qing.sync;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 回顧總結線程的建立
 */
public class ThreadNew {
    public static void main(String[] args) {
        new MyThread1().start();

        new Thread(new MyThread2()).start();

        FutureTask<Integer> futureTask = new FutureTask<>(new MyThread3());
        new Thread(futureTask).start();
        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1.繼承Thread類
class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}
//2.實現Runnable接口
class MyThread2 implements Runnable {
    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}
//3.實現Callable接口
class MyThread3 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("MyThread3");
        return 10;
    }
}
MyThread1
MyThread2
MyThread3
10
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程