欧美一区二区三区老妇人-欧美做爰猛烈大尺度电-99久久夜色精品国产亚洲a-亚洲福利视频一区二区

在Java項(xiàng)目中實(shí)現(xiàn)多線程并發(fā)編程的方法

在Java項(xiàng)目中實(shí)現(xiàn)多線程并發(fā)編程的方法？很多新手對(duì)此不是很清楚，為了幫助大家解決這個(gè)難題，下面小編將為大家詳細(xì)講解，有這方面需求的人可以來學(xué)習(xí)下，希望你能有所收獲。

成都創(chuàng)新互聯(lián)公司始終堅(jiān)持【策劃先行，效果至上】的經(jīng)營理念，通過多達(dá)10余年累計(jì)超上千家客戶的網(wǎng)站建設(shè)總結(jié)了一套系統(tǒng)有效的全網(wǎng)營銷推廣解決方案，現(xiàn)已廣泛運(yùn)用于各行各業(yè)的客戶，其中包括：成都iso認(rèn)證等企業(yè)，備受客戶表揚(yáng)。

Java 中的鎖通常分為兩種：

通過關(guān)鍵字 synchronized 獲取的鎖，我們稱為同步鎖，上一篇有介紹到：Java 多線程并發(fā)編程 Synchronized 關(guān)鍵字。
java.util.concurrent（JUC）包里的鎖，如通過繼承接口 Lock 而實(shí)現(xiàn)的 ReentrantLock（互斥鎖），繼承 ReadWriteLock 實(shí)現(xiàn)的 ReentrantReadWriteLock（讀寫鎖）。
本篇主要介紹 ReentrantLock（互斥鎖）。

ReentrantLock（互斥鎖）

ReentrantLock 互斥鎖，在同一時(shí)間只能被一個(gè)線程所占有，在被持有后并未釋放之前，其他線程若想獲得該鎖只能等待或放棄。

ReentrantLock 互斥鎖是可重入鎖，即某一線程可多次獲得該鎖。

公平鎖 and 非公平鎖

public ReentrantLock() {
    sync = new NonfairSync();
  }

  public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
  }

由 ReentrantLock 的構(gòu)造函數(shù)可見，在實(shí)例化 ReentrantLock 的時(shí)候我們可以選擇實(shí)例化一個(gè)公平鎖或非公平鎖，而默認(rèn)會(huì)構(gòu)造一個(gè)非公平鎖。

公平鎖與非公平鎖區(qū)別在于競爭鎖時(shí)的有序與否。公平鎖可確保有序性（FIFO 隊(duì)列），非公平鎖不能確保有序性（即使也有 FIFO 隊(duì)列）。

然而，公平是要付出代價(jià)的，公平鎖比非公平鎖要耗性能，所以在非必須確保公平的條件下，一般使用非公平鎖可提高吞吐率。所以 ReentrantLock 默認(rèn)的構(gòu)造函數(shù)也是“不公平”的。

一般使用

DEMO1：

public class Test {

  private static class Counter {

    private ReentrantLock mReentrantLock = new ReentrantLock();

    public void count() {
      mReentrantLock.lock();
      try {
        for (int i = 0; i < 6; i++) {
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        }
      } finally {
	      // 必須在 finally 釋放鎖
        mReentrantLock.unlock();
      }
    }
  }

  private static class MyThread extends Thread {

    private Counter mCounter;

    public MyThread(Counter counter) {
      mCounter = counter;
    }

    @Override
    public void run() {
      super.run();
      mCounter.count();
    }
  }

  public static void main(String[] var0) {
    Counter counter = new Counter();
    // 注：myThread1 和 myThread2 是調(diào)用同一個(gè)對(duì)象 counter
    MyThread myThread1 = new MyThread(counter);
    MyThread myThread2 = new MyThread(counter);
    myThread1.start();
    myThread2.start();
  }
}

DEMO1 輸出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5
Thread-1， i = 0
Thread-1， i = 1
Thread-1， i = 2
Thread-1， i = 3
Thread-1， i = 4
Thread-1， i = 5

DEMO1 僅使用了 ReentrantLock 的 lock 和 unlock 來提現(xiàn)一般鎖的特性，確保線程的有序執(zhí)行。此種場景 synchronized 也適用。

鎖的作用域

DEMO2：

public class Test {

  private static class Counter {

    private ReentrantLock mReentrantLock = new ReentrantLock();

    public void count() {
      for (int i = 0; i < 6; i++) {
        mReentrantLock.lock();
        // 模擬耗時(shí)，突出線程是否阻塞
        try{
          Thread.sleep(100);
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        } catch (InterruptedException e) {
          e.printStackTrace();
        } finally {
	        // 必須在 finally 釋放鎖
          mReentrantLock.unlock();
        }
      }
    }

    public void doOtherThing(){
      for (int i = 0; i < 6; i++) {
        // 模擬耗時(shí)，突出線程是否阻塞
        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
      }
    }
  }
  
  public static void main(String[] var0) {
    final Counter counter = new Counter();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.count();
      }
    }).start();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.doOtherThing();
      }
    }).start();
  }
}

DEMO2 輸出：

Thread-0， i = 0
Thread-1 doOtherThing， i = 0
Thread-0， i = 1
Thread-1 doOtherThing， i = 1
Thread-0， i = 2
Thread-1 doOtherThing， i = 2
Thread-0， i = 3
Thread-1 doOtherThing， i = 3
Thread-0， i = 4
Thread-1 doOtherThing， i = 4
Thread-0， i = 5
Thread-1 doOtherThing， i = 5

DEMO3:

public class Test {

  private static class Counter {

    private ReentrantLock mReentrantLock = new ReentrantLock();

    public void count() {
      for (int i = 0; i < 6; i++) {
        mReentrantLock.lock();
        // 模擬耗時(shí)，突出線程是否阻塞
        try{
          Thread.sleep(100);
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        } catch (InterruptedException e) {
          e.printStackTrace();
        } finally {
          // 必須在 finally 釋放鎖
          mReentrantLock.unlock();
        }
      }
    }

    public void doOtherThing(){
      mReentrantLock.lock();
      try{
        for (int i = 0; i < 6; i++) {
          // 模擬耗時(shí)，突出線程是否阻塞
          try {
            Thread.sleep(100);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
        }
      }finally {
        mReentrantLock.unlock();
      }

    }
  }

  public static void main(String[] var0) {
    final Counter counter = new Counter();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.count();
      }
    }).start();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.doOtherThing();
      }
    }).start();
  }
}

DEMO3 輸出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5
Thread-1 doOtherThing， i = 0
Thread-1 doOtherThing， i = 1
Thread-1 doOtherThing， i = 2
Thread-1 doOtherThing， i = 3
Thread-1 doOtherThing， i = 4
Thread-1 doOtherThing， i = 5

結(jié)合 DEMO2 和 DEMO3 輸出可見，鎖的作用域在于 mReentrantLock，因?yàn)樗鶃碜杂?mReentrantLock。

可終止等待

DEMO4：

public class Test {

  static final int TIMEOUT = 300;

  private static class Counter {

    private ReentrantLock mReentrantLock = new ReentrantLock();

    public void count() {
      try{
        //lock() 不可中斷
        mReentrantLock.lock();
        // 模擬耗時(shí)，突出線程是否阻塞
        for (int i = 0; i < 6; i++) {
          long startTime = System.currentTimeMillis();
          while (true) {
            if (System.currentTimeMillis() - startTime > 100)
              break;
          }
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        }
      } finally {
        // 必須在 finally 釋放鎖
        mReentrantLock.unlock();
      }
    }

    public void doOtherThing(){
      try{
        //lockInterruptibly() 可中斷，若線程沒有中斷，則獲取鎖
        mReentrantLock.lockInterruptibly();
        for (int i = 0; i < 6; i++) {
          // 模擬耗時(shí)，突出線程是否阻塞
          long startTime = System.currentTimeMillis();
          while (true) {
            if (System.currentTimeMillis() - startTime > 100)
              break;
          }
          System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
        }
      } catch (InterruptedException e) {
        System.out.println(Thread.currentThread().getName() + " 中斷 ");
      }finally {
        // 若當(dāng)前線程持有鎖，則釋放
        if(mReentrantLock.isHeldByCurrentThread()){
          mReentrantLock.unlock();
        }
      }
    }
  }

  public static void main(String[] var0) {
    final Counter counter = new Counter();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.count();
      }
    }).start();
    Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        counter.doOtherThing();
      }
    });
    thread2.start();
    long start = System.currentTimeMillis();
    while (true){
      if (System.currentTimeMillis() - start > TIMEOUT) {
        // 若線程還在運(yùn)行，嘗試中斷
        if(thread2.isAlive()){
          System.out.println(" 不等了，嘗試中斷 ");
          thread2.interrupt();
        }
        break;
      }
    }
  }
}

DEMO4 輸出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
不等了，嘗試中斷
Thread-1 中斷
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5

線程 thread2 等待 300ms 后 timeout，中斷等待成功。

若把 TIMEOUT 改成 3000ms，輸出結(jié)果：（正常運(yùn)行）

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5
Thread-1 doOtherThing， i = 0
Thread-1 doOtherThing， i = 1
Thread-1 doOtherThing， i = 2
Thread-1 doOtherThing， i = 3
Thread-1 doOtherThing， i = 4
Thread-1 doOtherThing， i = 5

定時(shí)鎖

DEMO5：

public class Test {

  static final int TIMEOUT = 3000;

  private static class Counter {

    private ReentrantLock mReentrantLock = new ReentrantLock();

    public void count() {
      try{
        //lock() 不可中斷
        mReentrantLock.lock();
        // 模擬耗時(shí)，突出線程是否阻塞
        for (int i = 0; i < 6; i++) {
          long startTime = System.currentTimeMillis();
          while (true) {
            if (System.currentTimeMillis() - startTime > 100)
              break;
          }
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        }
      } finally {
        // 必須在 finally 釋放鎖
        mReentrantLock.unlock();
      }
    }

    public void doOtherThing(){
      try{
        //tryLock(long timeout, TimeUnit unit) 嘗試獲得鎖
        boolean isLock = mReentrantLock.tryLock(300, TimeUnit.MILLISECONDS);
        System.out.println(Thread.currentThread().getName() + " isLock:" + isLock);
        if(isLock){
          for (int i = 0; i < 6; i++) {
            // 模擬耗時(shí)，突出線程是否阻塞
            long startTime = System.currentTimeMillis();
            while (true) {
              if (System.currentTimeMillis() - startTime > 100)
                break;
            }
            System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
          }
        }else{
          System.out.println(Thread.currentThread().getName() + " timeout");
        }
      } catch (InterruptedException e) {
        System.out.println(Thread.currentThread().getName() + " 中斷 ");
      }finally {
        // 若當(dāng)前線程持有鎖，則釋放
        if(mReentrantLock.isHeldByCurrentThread()){
          mReentrantLock.unlock();
        }
      }
    }
  }

  public static void main(String[] var0) {
    final Counter counter = new Counter();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.count();
      }
    }).start();
    Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        counter.doOtherThing();
      }
    });
    thread2.start();
  }
}

DEMO5 輸出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-1 isLock:false
Thread-1 timeout
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5

tryLock() 嘗試獲得鎖，tryLock(long timeout, TimeUnit unit) 在給定的 timeout 時(shí)間內(nèi)嘗試獲得鎖，若超時(shí)，則不帶鎖往下走，所以必須加以判斷。

ReentrantLock or synchronized

ReentrantLock 、synchronized 之間如何選擇？

ReentrantLock 在性能上 比 synchronized 更勝一籌。

ReentrantLock 需格外小心，因?yàn)樾枰@式釋放鎖，lock() 后記得 unlock()，而且必須在 finally 里面，否則容易造成死鎖。
synchronized 隱式自動(dòng)釋放鎖，使用方便。

ReentrantLock 擴(kuò)展性好，可中斷鎖，定時(shí)鎖，自由控制。
synchronized 一但進(jìn)入阻塞等待，則無法中斷等待。

看完上述內(nèi)容是否對(duì)您有幫助呢？如果還想對(duì)相關(guān)知識(shí)有進(jìn)一步的了解或閱讀更多相關(guān)文章，請(qǐng)關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道，感謝您對(duì)創(chuàng)新互聯(lián)的支持。

網(wǎng)頁題目：在Java項(xiàng)目中實(shí)現(xiàn)多線程并發(fā)編程的方法
標(biāo)題鏈接：http://www.chinadenli.net/article6/pieoog.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供響應(yīng)式網(wǎng)站、企業(yè)網(wǎng)站制作、品牌網(wǎng)站設(shè)計(jì)、ChatGPT、微信小程序、網(wǎng)站策劃

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請(qǐng)盡快告知，我們將會(huì)在第一時(shí)間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場，如需處理請(qǐng)聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時(shí)需注明來源： 創(chuàng)新互聯(lián)

成都定制網(wǎng)站網(wǎng)頁設(shè)計(jì)