Java 併發小記

首先，講講相位器Phaser 

很多人不理解，其實相位器是有phase這個概念的，register增加一個part,多個register動態申請了part。當一次所有register的parts都到達時，相位phase自動加一

看如下代碼：

public class PhaserDemo
{
   public static void main(String[] args)
   {
      List<Runnable> tasks = new ArrayList<>();
      tasks.add(() -> System.out.printf("%s running at %d%n", 
                                        Thread.currentThread().getName(),
                                        System.currentTimeMillis()));
      tasks.add(() -> System.out.printf("%s running at %d%n", 
                                        Thread.currentThread().getName(),
                                        System.currentTimeMillis()));
      runTasks(tasks);
   }

   static void runTasks(List<Runnable> tasks) 
   {
      final Phaser phaser = new Phaser(1); // "1" (register self)
//      phaser.bulkRegister(3);
      // create and start threads
      for (final Runnable task: tasks)
      {
         System.out.println("register:" + phaser.register());
//         phaser.
         Runnable r = () ->
                      {
                         while (!phaser.isTerminated()) {
                            try {
                               Thread.sleep(50 + (int) (Math.random() * 300));
                            } catch (InterruptedException ie) {
                               System.out.println("interrupted thread");
                            }
                            System.out.println("arrived Runnable:" + phaser.arriveAndAwaitAdvance()); // await the ...
                            // creation of ...
                            // all tasks
                            task.run();
                         }
                      };
         //Executors.newSingleThreadExecutor().execute(r);
         new Thread(r).start();
      }
      // allow threads to start and deregister self
      System.out.println("arrived out:" + phaser.arriveAndDeregister());

      System.out.println("over");
   }
}

再來講講 ReentrantReadWriteLock

JAVA的併發包提供了讀寫鎖ReentrantReadWriteLock，它表示兩個鎖，一個是讀操作相關的鎖，稱爲共享鎖；一個是寫相關的鎖，稱爲排他鎖，描述如下：

線程進入讀鎖的前提條件：

沒有其他線程的寫鎖，

沒有寫請求或者有寫請求，但調用線程和持有鎖的線程是同一個。

線程進入寫鎖的前提條件：

沒有其他線程的讀鎖

沒有其他線程的寫鎖

而讀寫鎖有以下三個重要的特性：

（1）公平選擇性：支持非公平（默認）和公平的鎖獲取方式，吞吐量還是非公平優於公平。

（2）重進入：讀鎖和寫鎖都支持線程重進入。

（3）鎖降級：遵循獲取寫鎖、獲取讀鎖再釋放寫鎖的次序，寫鎖能夠降級成爲讀鎖。

簡言之

讀讀共享，寫寫互斥，讀寫互斥，寫讀互斥

 

class MyTask {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void read() {
        try {
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + " start");
            Thread.sleep(10000);
            System.out.println(Thread.currentThread().getName() + " end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write() {
        try {
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + " start");
            Thread.sleep(10000);
            System.out.println(Thread.currentThread().getName() + " end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }
}

public class ReentrantReadWriteTest {
    public static void main(String[] args) {
        final MyTask myTask = new MyTask();

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                myTask.read();
            }
        });
        t1.setName("t1(read)");

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                myTask.read();
            }
        });
        t2.setName("t2(read)");

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

        //  讀寫互斥

        Thread t3 = new Thread(new Runnable() {

            @Override
            public void run() {
                myTask.read();
            }
        });
        t3.setName("t3(read)");

        Thread t4 = new Thread(new Runnable() {

            @Override
            public void run() {
                myTask.write();
            }
        });
        t4.setName("t4(write)");

        t3.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t4.start();
    }
}