java并发编程

为什么需要并发
  并发其实是一种解耦合的策略，它帮助我们把做什么（目标）和什么时候做（时机）分开。这样做可以明显改进应用程序的吞吐量（获得更多的CPU调度时间）和结构（程序有多个部分在协同工作）。比如可以发挥多处理器的强大能力、建模更加简单、简化异步事件的处理、使用户界面的相应更加灵敏。做过Java Web开发的人都知道，Java Web中的Servlet程序在Servlet容器的支持下采用单实例多线程的工作模式，Servlet容器为你处理了并发问题。

package com.wise.tiger;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;


public class SocketDemo {
    public static void main(String[] args) throws Exception{
        var server = new ServerSocket(8888);

        for(int i = 0; i < 20; i++){
            var client = server.accept();//等待客户端的连接
            System.out.println("ip:" + client.getInetAddress());
            new Thread(new Talk(client)).start();
        }
        System.out.println("服务结束");
    }

    static class Talk implements Runnable{
        private Socket client;
        public Talk(Socket socket){
            this.client = socket;
        }
        @Override
        public void run() {
            try {
                var reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
                var writer = client.getOutputStream();
                while(true){
                    String content = reader.readLine();
                    writer.write(content.getBytes());
                    writer.write("\r\n".getBytes());
                    if("0".equals(content)) break;
                }
                reader.close();
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

线程同步

       线程同步用于协调相互依赖的线程的执行。如果一个共享资源被多个线程同时访问，可能会遭到破坏。假设创建并启动100个线程，每个线程都往同一个账户中添加一元钱。

public class Account {
    private int balance;
    public int getBalance() {
        return balance;
    }
    public void deposit(int amount){
　　　　　//为了故意放大数据破坏的可能性，采用下列语句，其实可用 balance += amount；代替
　　　　 int newBalance = balance + amount；
        try {
            Thread.sleep(10);
        } catch(InterruptedException e){}
　　　　 balance = newBalance;
    }
}

public class AccountSync {
    private static Account account = new Account();
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        for(int i = 0; i < 100; i++) {
            service.execute(() -> account.deposit(1));
        }
        service.shutdown();
        while (!service.isTerminated());
        System.out.println(account.getBalance());
    }
}

显示锁

基于synchronized关键字的锁机制有以下问题：

• 锁只有一种类型，而且对所有同步操作都是一样的作用
• 锁只能在代码块或方法开始的地方获得，在结束的地方释放
• 线程要么得到锁，要么阻塞，没有其他的可能性

Java 5对锁机制进行了重构，提供了显示的锁，这样可以在以下几个方面提升锁机制：

• 可以添加不同类型的锁，例如读取锁和写入锁
• 可以在一个方法中加锁，在另一个方法中解锁
• 可以使用tryLock方式尝试获得锁，如果得不到锁可以等待、回退或者干点别的事情，当然也可以在超时之后放弃操作

显示的锁都实现了java.util.concurrent.Lock接口，主要有两个实现类：

• ReentrantLock - 比synchronized稍微灵活一些的重入锁
• ReentrantReadWriteLock - 在读操作很多写操作很少时性能更好的一种重入锁

注意：解锁的方法unlock的调用最好能够在finally块中，因为这里是释放外部资源最好的地方，当然也是释放锁的最佳位置，因为不管正常异常可能都要释放掉锁来给其他线程以运行的机会。

生产者/消费者

   假设使用缓冲区存储工作任务Task。缓冲区的大小是受限的，缓冲区提供write（Task task）方法将一个Task实例添加到缓冲区，还提供read()方法从缓冲区中读取和删除一个task。为了同步这个操作，使用具有两个条件的锁：notEmpty（缓冲区非空）和notFull（缓冲区未满）。当任务向缓冲区添加一个工作任务Task时，如果缓冲区是满的，那么任务将会等待notFull条件。当任务从缓冲区读取一个工作任务Task时，如果缓冲区是空的，那么任务将会等待notEmpty条件。

   缓冲区实际是一个先进先出的队列。条件notEmpty和notFull和锁捆绑在一起。在应用一个条件之前必须获取一个锁。如果使用wait()和notify()来重写这个例子，必须指派两个对象作为监视器。

package com.wise.tiger;
import java.util.LinkedList;
import java.util.UUID;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class QueueTask {
    private static Buffer buffer = new Buffer();
    public static void main(String[] args) {
        var pool = Executors.newFixedThreadPool(2);
        pool.execute(new Producer());
        pool.execute(new Consumer());
        pool.shutdown();
    }
    /**
     * 工作任务
     */
    private static class Task{
        private String id;
        public Task(){
            this.id = UUID.randomUUID().toString();
        }
        @Override
        public String toString(){
            return "Task["+id+"]";
        }
    }

    /**
     * 生产者：
     *
     */
    private static class Producer implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    Thread.sleep((int) (Math.random() * 10000));
                    var task = new Task();
                    buffer.write(task);
                    System.out.println("Producer[" + Thread.currentThread().getName() + "] put " + task);
                }
            } catch(InterruptedException e){
                e.printStackTrace();
            }
        }

    }
    /**
     * 消费者
     */
    static class Consumer implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    Thread.sleep((int) (Math.random() * 10000));
                    System.out.println("Consumer[" + Thread.currentThread().getName() + "] got " + buffer.read());
                }
            } catch(InterruptedException e){
                    e.printStackTrace();
            }
        }
    }


    /**
     * 缓冲区
     */
    private static class Buffer{
        private static final int CAPACITY = 20;
        private LinkedList<Task> queue = new LinkedList<>();

        private static Lock lock = new ReentrantLock();

        private static Condition notEmpty = lock.newCondition();
        private static Condition notFull = lock.newCondition();

        /**
         * 往队列中添加数据【Task】
         * @param value Task
         */
        public void write(Task value){
            lock.lock();
            try {
                while(queue.size() >= CAPACITY){
                    System.out.println("wait for notFull condition");
                    notFull.await();
                }
                queue.offer(value);
                notEmpty.signal();//signal notEmpty condition
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        public Task read(){
            Task value = null;
            lock.lock();
            try {
                while(queue.isEmpty()){
                    System.out.println("wait for notEmpty condition");
                    notEmpty.await();
                }
                value = queue.remove();
                notFull.signal();//signal notFull condition
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
                return value;
            }
        }
    }
}
 

阻塞队列

基于BlockingQueue的实现

package edu.uestc.avatar;

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


/**
 * java集合框架提供了ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue来支持阻塞队列
 * 阻塞队列：试图向满队列添加元素或者从空队列删除元素会导致线程阻塞
 */
public class ProducerConsumerUsingBlockingQueue {
    private static ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(5);
    
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(new Producer());
        executor.execute(new Consumer());
        executor.shutdown();
    }
    
    private static class Producer implements Runnable{
        @Override
        public void run() {
            try {
                int value = 1;
                while(true) {
                    System.out.println("生产者生产数据：" + value);
                    queue.put(value++);
                    Thread.sleep((long)(Math.random() * 5000));
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    private static class Consumer implements Runnable{
        @Override
        public void run() {
            try {
                while(true) {
                    System.out.println("消费者消费数据：" + queue.take());
                    Thread.sleep((long)(Math.random() * 5000));
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

CountDownLatch

CountDownLatch是一种简单的同步模式，它让一个线程可以等待一个或多个线程完成它们的工作从而避免对临界资源并发访问所引发的各种问题。下面借用别人的一段代码（我对它做了一些重构）来演示CountDownLatch是如何工作的。

package com.wise.tiger;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CountdownLatchTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final CountDownLatch cdOrder = new CountDownLatch(1);
        final CountDownLatch cdAnswer = new CountDownLatch(3);        
        for(int i = 0;i < 3; i++){
            Runnable runnable = new Runnable(){
                    public void run(){
                    try {
                        System.out.println("线程" + Thread.currentThread().getName() + 
                                "正准备接受命令");                        
                        cdOrder.await();
                        System.out.println("线程" + Thread.currentThread().getName() + 
                        "已接受命令");                                
                        Thread.sleep((long)(Math.random()*10000));    
                        System.out.println("线程" + Thread.currentThread().getName() + 
                                "回应命令处理结果");                        
                        cdAnswer.countDown();                        
                    } catch (Exception e) {
                        e.printStackTrace();
                    }                
                }
            };
            service.execute(runnable);
        }        
        try {
            Thread.sleep((long)(Math.random()*10000));
        
            System.out.println("线程" + Thread.currentThread().getName() + 
                    "即将发布命令");                        
            cdOrder.countDown();
            System.out.println("线程" + Thread.currentThread().getName() + 
            "已发送命令，正在等待结果");    
            cdAnswer.await();
            System.out.println("线程" + Thread.currentThread().getName() + 
            "已收到所有响应结果");    
        } catch (Exception e) {
            e.printStackTrace();
        }                
        service.shutdown();
    }
}

package com.wise.tiger;

import java.util.concurrent.CountDownLatch;

/**
 * 工人类
 *
 */
class Worker {
    private String name;        // 名字
    private long workDuration;  // 工作持续时间

    /**
     * 构造器
     */
    public Worker(String name, long workDuration) {
        this.name = name;
        this.workDuration = workDuration;
    }

    /**
     * 完成工作
     */
    public void doWork() {
        System.out.println(name + " begins to work...");
        try {
            Thread.sleep(workDuration); // 用休眠模拟工作执行的时间
        } catch(InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println(name + " has finished the job...");
    }
}

/**
 * 测试线程
 *
 */
class WorkerTestThread implements Runnable {
    private Worker worker;
    private CountDownLatch cdLatch;

    public WorkerTestThread(Worker worker, CountDownLatch cdLatch) {
        this.worker = worker;
        this.cdLatch = cdLatch;
    }

    @Override
    public void run() {
        worker.doWork();        // 让工人开始工作
        cdLatch.countDown();    // 工作完成后倒计时次数减1
    }
}

class CountDownLatchTest {

    private static final int MAX_WORK_DURATION = 5000;  // 最大工作时间
    private static final int MIN_WORK_DURATION = 1000;  // 最小工作时间

    // 产生随机的工作时间
    private static long getRandomWorkDuration(long min, long max) {
        return (long) (Math.random() * (max - min) + min);
    }

    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(2);   // 创建倒计时闩并指定倒计时次数为2
        Worker w1 = new Worker("Peppa", getRandomWorkDuration(MIN_WORK_DURATION, MAX_WORK_DURATION));
        Worker w2 = new Worker("Emily", getRandomWorkDuration(MIN_WORK_DURATION, MAX_WORK_DURATION));

        new Thread(new WorkerTestThread(w1, latch)).start();
        new Thread(new WorkerTestThread(w2, latch)).start();

        try {
            latch.await();  // 等待倒计时闩减到0
            System.out.println("All jobs have been finished!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

信号量Semaphore

可以使用信号量来限制访问一个共享资源的线程数。在访问资源之前，线程必须从信号量获取许可。在访问完资源之后，这个线程必须将许可返回给信号量。

package com.wise.tiger;

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

public class SemaphoreTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final  Semaphore sp = new Semaphore(3);
        for(int i=0;i<10;i++){
            Runnable runnable = new Runnable(){
                    public void run(){
                    try {
                        sp.acquire();
                    } catch (InterruptedException e1) {
                        e1.printStackTrace();
                    }
                    System.out.println("线程" + Thread.currentThread().getName() + 
                            "进入，当前已有" + (3-sp.availablePermits()) + "个并发");
                    try {
                        Thread.sleep((long)(Math.random()*10000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程" + Thread.currentThread().getName() + 
                            "即将离开");                    
                    sp.release();
                    //下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元
                    System.out.println("线程" + Thread.currentThread().getName() + 
                            "已离开，当前已有" + (3-sp.availablePermits()) + "个并发");                    
                }
            };
            service.execute(runnable);            
        }
    }
}

场景介绍：有一个停车场只有5个车位，现在有100辆车要去抢这个5个车位，理想情况下最多只有五辆车同时可以抢到车位，那么没有抢到车位的车只能等到，其他的车让出车位，才有机会去使用该车位。

public class CarPark {
    public static void main(String[] args) {
        //阻塞队列
        BlockingQueue<String> parks = new LinkedBlockingQueue<>(5);

        parks.offer("车位一");
        parks.offer("车位二");
        parks.offer("车位三");
        parks.offer("车位四");
        parks.offer("车位五");

        ExecutorService executorService = Executors.newCachedThreadPool();

        //如博文中所说的初始值为5， 专业的说法就是5个许可证
        Semaphore semaphore = new Semaphore(5);

        for (int i = 0; i < 100; i++) {
            final int no = i;
            Thread t1 = new Thread(() -> {
                try {
                    /**
                     * 获取许可，首先判断semaphore内部的数字是否大于0，如果大于0，
                     * 才能获得许可，然后将初始值5减去1，线程才会接着去执行；如果没有
                     * 获得许可(原因是因为已经有5个线程获得到许可，semaphore内部的数字为0)，
                     * 线程会阻塞直到已经获得到许可的线程，调用release()方法，释放掉许可，
                     * 也就是将semaphore内部的数字加1，该线程才有可能获得许可。
                     */
                    semaphore.acquire();
                    /**
                     *  对应的线程会到阻塞对，对应车辆去获取到车位，如果没有拿到一致阻塞，
                     *  直到其他车辆归还车位。
                     */
                    String park = parks.take();  
                    System.out.println("车辆【" + no + "】获取到: " + park);
                    Thread.sleep((long) Math.random() * 6000);
                    semaphore.release(); //线程释放掉许可，通俗来将就是将semaphore内部的数字加1
                    parks.offer(park);  //归还车位
                    System.out.println("车辆【" + no + "】离开 " + park);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            executorService.execute(t1);
        }
    }
}

     1965年，荷兰计算机科学家图灵奖得主Edsger Wybe Dijkstra提出并解决了一个他称之为哲学家进餐的同步问题。这个问题可以简单地描述如下：五个哲学家围坐在一张圆桌周围，每个哲学家面前都有一盘通心粉。由于通心粉很滑，所以需要两把叉子才能夹住。相邻两个盘子之间放有一把叉子如下图所示。哲学家的生活中有两种交替活动时段：即吃饭和思考。当一个哲学家觉得饿了时，他就试图分两次去取其左边和右边的叉子，每次拿一把，但不分次序。如果成功地得到了两把叉子，就开始吃饭，吃完后放下叉子继续思考。
  把上面问题中的哲学家换成线程，把叉子换成竞争的临界资源，上面的问题就是线程竞争资源的问题。如果没有经过精心的设计，系统就会出现死锁、活锁、吞吐量下降等问题。

  下面是用信号量原语来解决哲学家进餐问题的代码，使用了Java 5并发工具包中的Semaphore类（代码不够漂亮但是已经足以说明问题了）。

package com.wise.tiger;

import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * 存放线程共享信号量上下文
 */
public class SemaphoreContext {
    public static final int NUM_OF_FORKS = 5;//叉子数量（资源)
    public static final int NUM_OF_PHILO = 5;//哲学家数量(线程)
    public static Semaphore[] forks;
    public static Semaphore counter;

    static{
        forks = new Semaphore[NUM_OF_FORKS];
        for(int i = 0 ; i < forks.length; i++){
            forks[i] = new Semaphore(1);
        }
        counter = new Semaphore(NUM_OF_PHILO - 1);
    }
    public static void putFork(int index,boolean leftFirst) throws Exception{
        if(leftFirst) {
            forks[index].acquire();
            forks[(index + 1) % NUM_OF_PHILO].acquire();
        }
        else {
            forks[(index + 1) % NUM_OF_PHILO].acquire();
            forks[index].acquire();
        }
    }

    public static void takeFork(int index,boolean leftFirst) throws Exception{
        if(leftFirst) {
            forks[index].release();
            forks[(index + 1) % NUM_OF_PHILO].release();
        }
        else {
            forks[(index + 1) % NUM_OF_PHILO].release();
            forks[index].release();
        }
    }

    static class Philo implements Runnable{
        private int index;
        private String name;

        public Philo(int index, String name) {
            this.index = index;
            this.name = name;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    counter.acquire();
                    boolean isLeftFirst = index % 2 == 0;
                    putFork(index, isLeftFirst);
                    System.out.println(name + "正在吃通心粉。。。。。");
                    takeFork(index, isLeftFirst);
                    System.out.println(name + "吃完了，正在思考");
                    counter.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        Philo[] philos = {new Philo(0,"peppa"),
                new Philo(1,"pedro"),
                new Philo(2,"emily"),
                new Philo(3,"suzy"),
                new Philo(4,"danny"),};
        var pool = Executors.newCachedThreadPool();
        for(int i= 0; i < philos.length;i++){
            pool.execute(philos[i]);
        }
        pool.shutdown();

    }
}

Exchanger

Exchanger是自jdk1.5起开始提供的工具套件，一般用于两个工作线程之间交换数据。在本文中我将采取由浅入深的方式来介绍分析这个工具类。首先我们来看看官方的api文档中的叙述：

A synchronization point at which threads can pair and swap elements within pairs. Each thread presents some object on entry to the exchange method, matches with a partner thread, and receives its partner's object on return. An Exchanger may be viewed as a bidirectional form of a SynchronousQueue. Exchangers may be useful in applications such as genetic algorithms and pipeline designs.

    在以上的描述中，有几个要点：

• 此类提供对外的操作是同步的；
• 用于成对出现的线程之间交换数据；
• 可以视作双向的同步队列；
• 可应用于基因算法、流水线设计等场景。

   接着看api文档，这个类提供对外的接口非常简洁，一个无参构造函数，两个重载的范型exchange方法：
public V exchange(V x) throws InterruptedException
public V exchange(V x, long timeout, TimeUnit unit) throws InterruptedException, TimeoutException
   从官方的javadoc可以知道，当一个线程到达exchange调用点时，如果它的伙伴线程此前已经调用了此方法，那么它的伙伴会被调度唤醒并与之进行对象交换，然后各自返回。如果它的伙伴还没到达交换点，那么当前线程将会被挂起，直至伙伴线程到达——完成交换正常返回；或者当前线程被中断——抛出中断异常；又或者是等候超时——抛出超时异常。

package com.wise.tiger;

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

public class ExchangerTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final Exchanger exchanger = new Exchanger();
        service.execute(new Runnable(){
            public void run() {
                try {                
                    String data1 = "白粉";
                    System.out.println("线程" + Thread.currentThread().getName() + 
                    "正在把数据" + data1 +"换出去");            Thread.sleep((long)(Math.random()*10000));
                    String data2 = (String)exchanger.exchange(data1);
                    System.out.println("线程" + Thread.currentThread().getName() + 
                    "换回的数据为" + data2);
                }catch(Exception e){
                }
            }    
        });
        service.execute(new Runnable(){
            public void run() {
                try {                
                    String data1 = "美金";
                    System.out.println("线程" + Thread.currentThread().getName() + 
                    "正在把数据" + data1 +"换出去");
                    Thread.sleep((long)(Math.random()*10000));                    
                    String data2 = (String)exchanger.exchange(data1);
                    System.out.println("线程" + Thread.currentThread().getName() + 
                    "换回的数据为" + data2);
                }catch(Exception e){
                }                
            }    
        });        
    }
}

package com.wise.tiger;

import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.*;
public class ExchangerDemo {
    public static void main(String[] args) {
        var executor = Executors.newCachedThreadPool();
        final Exchanger exchanger = new Exchanger();
        executor.execute(new Runnable() {
            String data1 = "克拉克森，小拉里南斯";
            @Override
            public void run() {
                nbaTrade(data1, exchanger);
            }
        });
        executor.execute(new Runnable() {
            String data1 = "格里芬";
            @Override
            public void run() {
                nbaTrade(data1, exchanger);
            }
        });
        executor.execute(new Runnable() {
            String data1 = "史蒂芬.裤裆里";
            @Override
            public void run() {
                nbaTrade(data1, exchanger);
            }
        });
        executor.shutdown();
    }
    private static void nbaTrade(String data1, Exchanger exchanger) {
        try {
         System.out.println(Thread.currentThread().getName() + "在交易截止之前把 " + data1 + " 交易出去");
            Thread.sleep((long) (Math.random() * 1000));
            String data2 = (String) exchanger.exchange(data1);
            System.out.println(Thread.currentThread().getName() + "交易得到" + data2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}