2. 程式人生 > >實戰Java高併發程式設計（3.1同步控制）

實戰Java高併發程式設計（3.1同步控制）

阿新 • • 發佈：2018-11-21

3.1重入鎖

重入鎖使用java.util.concurrent.locks.ReentrantLock來實現

public class Test implements Runnable {

    public static ReentrantLock lock = new ReentrantLock();
    public static int i = 0;

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
                lock.lock();
                try {
                    i++;
                }finally {
                    lock.unlock();
                }
        }
    }

    public static void main(String[] args) throws Exception {
        Test t1 = new Test();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t1);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(i);
    }
}

重入鎖與synchronized相比有明顯的操作過程，開發人員必須指定何時加鎖，何時解鎖。同時，重入鎖是可以反覆新增的。一個縣城可以連續兩次獲得同一把鎖。

    lock.lock();
    lock.lock();
    try {
        i++;
        } finally {
            lock.unlock();
            lock.unlock();
        }

3.1.1重入鎖可以被中斷

public class Test implements Runnable {

    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;

    /**
     * 控制加鎖順序，方便構成死鎖
     *
     * @param lock
     */
    public Test(int lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            if (lock == 1) {
                lock1.lockInterruptibly();  // 以可以響應中斷的方式加鎖
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock2.lockInterruptibly();
            } else {
                lock2.lockInterruptibly();  // 以可以響應中斷的方式加鎖
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock1.lockInterruptibly();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock1.isHeldByCurrentThread()) {
                lock1.unlock();
            }
            if (lock2.isHeldByCurrentThread()) {
                lock2.unlock();
            }
            System.err.println(Thread.currentThread().getId() + "退出！");
        }
    }

    public static void main(String[] args) throws Exception {
        Test t1 = new Test(1);
        Test t2 = new Test(2);
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        System.out.println("thread1: "+thread1.getId());
        System.out.println("thread2: "+thread2.getId());
        thread1.start();
        thread2.start();
        Thread.sleep(1000);
        thread2.interrupt();//③給t2執行緒狀態標記為中斷
    }
}

t1、t2執行緒開始執行時，會分別持有lock1和lock2而請求lock2和lock1，這樣就發生了死鎖。但是，在③處給t2執行緒狀態標記為中斷後，持有重入鎖lock2的執行緒t2會響應中斷，並不再繼續等待lock1，同時釋放了其原本持有的lock2，這樣t1獲取到了lock2，正常執行完成。t2也會退出，但只是釋放了資源並沒有完成工作。

3.1.2鎖申請等待限時

可以使用 tryLock()或者tryLock(long timeout, TimeUtil unit) 方法進行一次限時的鎖等待。

前者不帶引數，這時執行緒嘗試獲取鎖，如果獲取到鎖則繼續執行，如果鎖被其他執行緒持有，則立即返回 false ，也就是不會使當前執行緒等待，所以不會產生死鎖。
後者帶有引數，表示在指定時長內獲取到鎖則繼續執行，如果等待指定時長後還沒有獲取到鎖則返回false。

public class Test implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            if (lock.tryLock(5, TimeUnit.SECONDS)){
                Thread.sleep(6000);
            }else {
                System.out.println("get lock failed");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            if (lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        Test test = new Test();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.start();
        t2.start();
    }
}

tryLock()方法接受的兩個引數，一個表示等待時長，另一個表示計時單位。在本例中，由於佔用鎖的程序持有鎖長達6秒，另一個執行緒無法再5秒的等待時間中得到鎖，會返回false。

3.2公平鎖

在大多數情況下，鎖的申請並不是公平的，先申請的執行緒並不一定在鎖可用時先使用。要實現公平鎖需要系統維護一個有序數列，效能較低，因此，預設情況下，鎖都是非公平的。

public class Test implements Runnable {
    /**
     * 預設為false,表示為非公平鎖
     */
    public static ReentrantLock lock = new ReentrantLock(true);

    @Override
    public void run() {
        while (true){
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"獲得鎖");
            }finally {
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) {
        Test test = new Test();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.start();
        t2.start();
    }
}

兩個執行緒會交替輸出。如果是非公平鎖：

執行緒1顯示一大堆，然後執行緒2顯示一大堆。一個執行緒會傾向於再次獲取已經持有的鎖。

3.3Condition條件

await()方法會使當前執行緒等待，同時釋放當前鎖，當其他執行緒使用signal()或者signalAll()方法時，執行緒會重新獲得鎖並執行。

public class Test implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();
    public static Condition condition = lock.newCondition();

    @Override
    public void run() {
        try {
            lock.lock();
            condition.await();
            System.out.println("Thread is going on");
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException{
        Test test = new Test();
        Thread t1 = new Thread(test);
        t1.start();
        Thread.sleep(2000);
        //通知執行緒繼續執行
        lock.lock();
        condition.signal();
        lock.unlock();
    }
}

3.4訊號量（Semaphore）

訊號量可以指導多個執行緒同時訪問某一資源。

acquire()方法嘗試獲取一個准入許可，若無法獲得，則執行緒等待。

tryAcquire()方法嘗試獲取一個許可，成功返回true，失敗返回false，不會等待。

release()用於執行緒訪問完資源後，釋放許可。

public class Test implements Runnable {
    final Semaphore semaphore = new Semaphore(5);

    @Override
    public void run() {
        try {
            semaphore.acquire();
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getId()+" done");
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws InterruptedException{
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        final Test test = new Test();
        for (int i = 0;i<20;i++){
            executorService.submit(test);
        }
    }
}

5個執行緒為一組同時訪問資源，但執行緒的順序隨機。

3.5ReadWriteLock讀寫鎖

讀寫鎖允許多個執行緒同時讀，但寫寫操作和讀寫操作間依然需要相互等待及持有鎖。

public class Test {
    private static Lock lock = new ReentrantLock();
    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = readWriteLock.readLock();
    private static Lock writeLock = readWriteLock.writeLock();
    private int value;

//    模擬讀操作
    public Object handleRead(Lock lock)throws InterruptedException{
        try {
            lock.lock();
//            讀操作耗時越多，讀寫鎖的優勢越明顯
            Thread.sleep(1000);
            return value;
        } finally {
            lock.unlock();
        }
    }

//    模擬寫操作
    public void handleWrite(Lock lock,int index) throws InterruptedException{
        try {
            lock.lock();
            Thread.sleep(1000);
            value = index;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        final Test test = new Test();
        Runnable readRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                    test.handleRead(readLock);
//                    test.handleRead(lock);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Runnable writeRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                    test.handleWrite(writeLock,new Random().nextInt());
//                    test.handleWrite(lock,new Random().nextInt());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0;i<18;i++){
            new Thread(readRunnable).start();
        }
        for (int i = 18;i<20;i++){
            new Thread(writeRunnable).start();
        }
    }
}

讀執行緒和寫執行緒可以並行，寫會阻塞讀，所以這段程式碼執行2秒多就結束，如果不用讀寫鎖，則需要20多秒。

3.6倒計時器：CountDownLatch

例如火箭發射倒計時，完成10項檢查才能發射火箭。

public class Test implements Runnable {
//    標明要完成10個任務
    static final CountDownLatch end = new CountDownLatch(10);
    static final Test test = new Test();

    @Override
    public void run() {
        try {
            Thread.sleep(new Random().nextInt(10) * 1000);
            System.out.println("check template");
            end.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException{
//        建立10個任務
        ExecutorService service = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            service.submit(test);
        }
//        等待檢查,要求主執行緒完成所有任務後才能執行
        end.await();
        System.out.println("Fire!");
        service.shutdown();
    }
}

3.7迴圈柵欄：CyclicBarrier

假設司令下達命令，要求10個士兵一起去完成一項任務。士兵需要先集合，再去完成任務。

public class Test {
    public static class Soldier implements Runnable {
        private String soldier;
        private final CyclicBarrier cyclic;

        Soldier(CyclicBarrier cyclic, String soldierName) {
            this.cyclic = cyclic;
            this.soldier = soldierName;
        }

        void doWork() {
            try {
                Thread.sleep(Math.abs(new Random().nextInt() % 10000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(soldier + " 任務完成");
        }

        @Override
        public void run() {
            try {
//                確定是否都集合完畢
                cyclic.await();
                doWork();
//                確定是否都完成工作
                cyclic.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    public static class BarrierRun implements Runnable {
        boolean flag;
        int N;

        public BarrierRun(boolean flag, int N) {
            this.flag = flag;
            this.N = N;
        }

        @Override
        public void run() {
            if (flag) {
                System.out.println("司令：[士兵" + N + "個，任務完成]");
            } else {
                System.out.println("司令：[士兵" + N + "個，集合完畢]");
                flag = true;
            }
        }
    }

    public static void main(String[] args) {
        final int N = 10;
        Thread[] allSoldier = new Thread[N];
        boolean flag = false;
        //迴圈呼叫這個計時器
        CyclicBarrier cyclic = new CyclicBarrier(N, new BarrierRun(flag, N));
        System.out.println("集合隊伍！");
        for (int i = 0; i < N; i++) {
            System.out.println("士兵" + i + "報道");
            allSoldier[i] = new Thread(new Soldier(cyclic, "士兵" + i));
            allSoldier[i].start();
        }
    }
}

3.8執行緒阻塞工具類：LockSupport

LockSupport可以線上程中的任何位置讓執行緒阻塞。

public class Test {
    public static Object u = new Object();
    static ChangeObjectThread t1 = new ChangeObjectThread("t1");
    static ChangeObjectThread t2 = new ChangeObjectThread("t2");

    public static class ChangeObjectThread extends Thread{
        public ChangeObjectThread(String name) {
            super.setName(name);
        }

        @Override
        public void run(){
            synchronized (u){
                System.out.println("in "+getName());
                LockSupport.park();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException{
        t1.start();
        Thread.sleep(100);
        t2.start();
        LockSupport.unpark(t1);
        LockSupport.unpark(t2);
        t1.join();
        t2.join();
    }
}

 

相關推薦

實戰Java高併發程式設計（3.1同步控制）

3.1重入鎖 重入鎖使用java.util.concurrent.locks.ReentrantLock來實現 public class Test implements Runnable { public static ReentrantLock lock = new Reentr

實戰Java高併發程式設計（3.2 執行緒池）

1.Executor jdk提供了一套Executor框架，本質上是一個執行緒池。 newFixedThreadPool()方法：該方法返回一個固定數量的執行緒池。該執行緒池中的執行緒數量始終不變，當有一個新任務提交時，執行緒池中若有空閒執行緒，則立即執行，若沒有，則任務會暫存在一個任

實戰Java高併發程式設計（五、並行模式與演算法）

5.1單例模式 單例模式：是一種常用的軟體設計模式，在它的核心結構中值包含一個被稱為單例的特殊類。一個類只有一個例項，即一個類只有一個物件例項。 　對於系統中的某些類來說，只有一個例項很重要，例如，一個系統中可以存在多個列印任務，但是隻能有一個正在工作的任務；售票時，一共有100張票，可有有

實戰Java高併發程式設計（四、鎖的優化及注意事項）

在多核時代，使用多執行緒可以明顯地提升系統的效能。但事實上，使用多執行緒會額外增加系統的開銷。對於單任務或單執行緒的應用來說，其主要資源消耗在任務本身。對於多執行緒來說，系統除了處理功能需求外，還需要維護多執行緒環境特有的資訊，如執行緒本身的元資料，執行緒的排程，執行緒上下文的切換等。 4.1有

實戰Java高併發程式設計（一）走進併發世界

阻塞（blocking）一個執行緒是阻塞的，那麼其它的執行緒釋放資源之前，當前執行緒無法繼續執行。使用synchronized或者重入鎖會使執行緒這是。 無飢餓（starvation-free）：對於非公平的鎖來說，系統允許高優先順序的執行緒插隊，會造成飢餓；而公平的鎖則不會造成飢餓。 無障礙（obstruc

《實戰Java高併發程式設計》學習總結（3）

第6章  java8與併發 1 顯式函式指函式與外界交換資料的唯一渠道就是引數和返回值，顯式函式不會去讀取或者修改函式的外部狀態。這樣的函式對於除錯和排錯是有益的。 2 函數語言程式設計式申明式的程式設計方式。而命令式則喜歡大量使用可變物件和指令。如下 // 指令式程式設計 p

《實戰Java高併發程式設計》學習總結（1）

第1章 走入並行世界 1 併發(Concurrency)和並行(Parallelism)都可以表示兩個或多個任務一起執行。但併發偏重於多個任務交替執行，而多個任務之間有可能還是序列。並行是真正意義上的“同時執行”。 2 有關並行的兩個重要定律。Amdahl定律強調當序列比例一定時，加速比是有

《實戰Java高併發程式設計》學習總結（2）

第3章  JDK併發包 1 synchronized的功能擴充套件：重入鎖。使用java.util.concurrent.locks.ReentrantLock類來實現。 import java.util.concurrent.locks.ReentrantLock; publi

02.第二階段、實戰Java高併發程式設計模式-5.JDK併發包1

1. 各種同步控制工具的使用 ..........................................................................................3 1.1. ReentrantLock .........................

實戰Java高併發程式設計.epub

    【下載地址】 在過去單核CPU時代，單任務在一個時間點只能執行單一程式，隨著多核CPU的發展，並行程式開發就顯得尤為重要。 《實戰Java高併發程式設計》主要介紹基於Java的並行程式設計基礎、思路、方法和實戰。第一，立足於併發程式基礎，詳細介紹Ja

2018最新實戰Java高併發程式設計

在過去單核CPU時代，單任務在一個時間點只能執行單一程式，隨著多核CPU的發展，並行程式開發就顯得尤為重要。《實戰Java高併發程式設計》主要介紹基於Java的並行程式設計基礎、思路、方法和實戰。第一，立足於併發程式基礎，詳細介紹Java中進行並行程式設計的基本方法。第二，進一步詳細介紹JDK中對並

頂級架構師學習——第二階段：實戰Java高併發程式設計

1、什麼是並行？ 並行處理（ParallelProcessing）是計算機系統中能同時執行兩個或更多個處理機的一種計算方法。處理機可同時工作於同一程式的不同方面。並行處理的主要目的是節省大型和複雜問題的解決時間。 2、為什麼需要並行？ 平行計算只有在  影象處理  和 

實戰java高併發程式設計之CountDownLatch原始碼分析

首先看第一個！ CountDownLatch 使用場景 CountDownLatch類是常見的併發同步控制類，適用於某一執行緒的執行在其他多個執行緒執行完成之後，比如火箭發射前需要各項指標檢查，只有當各項指標檢查完才能發射，再比如解析多個excel文件，只有當

實戰java高併發程式設計之ReentrantReadWriteLoc原始碼分析

前面分析了併發工具類CountDownLatch和CyclicBarrier，本文分享分析比較重要的ReentrantReadWriteLock。 使用場景 以前的同步方式需要對讀、寫操作進行同步，讀讀之間，讀寫之間，寫寫之間等；工程師們發現讀讀之間並不會影響資

實戰java高併發程式設計 原始碼 source code

@rover這個是C++模板 --胡滿超 stack<Postion> path__;這個裡面 ”<> “符號是什麼意思？我在C++語言裡面沒見過呢？ 初學者，大神勿噴。

《實戰Java高併發程式設計》讀後感

寫在前面無關的內容        白駒過隙，看下日曆已經畢業4年多，加上在大學裡的4年，算算在計算機界也躺了八年，按照格拉德韋爾的1萬小時定律差不多我也該成為行業的專家了，然後並沒有。當看著“什麼是Java？”、“什麼是程式？”、“多執行緒是什麼？”、“怎麼構建一個合理的大型

Java高併發程式設計（十二）：Executor框架

Java中的執行緒既是工作單元，也是執行單元。工作單元包括Runnable和Callable，而執行單元是由Executor框架支援。 1. Executor框架簡介 1.1 Executor框架的兩級排程模型 在HotSpot VM的執行緒模型中，Java執行緒（java.la

Java高併發程式設計（十一）：Java中執行緒池

在開發過程中，合理地使用執行緒池能夠帶來3個好處。 降低資源消耗。通過重複利用已建立的執行緒降低執行緒建立和銷燬造成的消耗。 提高響應速度。當任務到達時，任務可以不需要等到執行緒建立就能立即執行。 提高執行緒的可管理性。執行緒是稀缺資源，如果無限制地建立

Java高併發程式設計（十）：Java併發工具類

1. 等待多執行緒完成的CountDownLatch CountDownLatch允許一個或多個執行緒等待其他執行緒完成操作。 1.1 應用場景 假如有這樣一個需求：我們需要解析一個Excel裡多個sheet的資料，此時可以考慮使用多 執行緒，每個執行緒解析一個sheet裡的資料

Java高併發程式設計（八）：Java併發容器和框架

1. ConcurrentHashMap 1.1 ConcurrentHashMap的優勢 在併發程式設計中使用HashMap可能導致程式死迴圈。而使用執行緒安全的HashTable效率又非 常低下，基於以上兩個原因，便有了ConcurrentHashMap的登場機會。