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();
    }
}