《图解Java多线程设计模式》之二：Single Thread Execution 模式

一，什么是SingleThreadExecution模式？
同一时间内只能让一个线程执行处理

二，例子

1.不安全的情况

用程序模拟 三个人频繁地通过一个只允许一个人经过的门。当人通过时，统计人数便会增加，并记录通行者的姓名和地址

门：

public class Gate {

    private int counter = 0;
    private String name = "nobody";
    private String address = "nowhere";
    public void pass(String name ,String address){
        this.counter++;
        this.name = name;
        this.address = address;
        check();
    }

    public String toString(){
        return "NO."+counter+":"+name+", "+address;
    }

    private void check() {
        if (name.charAt(0) != address.charAt(0)){
            System.out.println("*****borken******"+toString());
        }
    }

}

通行者：

public class UserThread extends Thread{
    private final Gate gate;
    private final String myName;
    private final String myAddress;

    public UserThread(Gate gate, String myName,String myAddress){
        this.gate = gate;
        this.myName = myName;
        this.myAddress = myAddress;
    }

    @Override
    public void run() {
        System.out.println(myName+" is ready....");
　　　　　//频繁通过门
        while (true){
            gate.pass(myName,myAddress);
        }
    }
}

创建三个通过门的人

public class Test {

    public static void main(String[] args) {
        Gate gate = new Gate();
        new UserThread(gate,"aaa","aa").start();
        new UserThread(gate,"bbb","bb").start();
        new UserThread(gate,"ccc","cc").start();
    }
}

运行结果：

ccc is ready....
*****borken******NO.4717:aaa, bb
分析：

当人通过门时，会记录人的名字和人的地址。但从这行结果看，这和我们预期的结果不一样。

2.安全的例子

上面的问题就出现在同一时刻不只有一个人通过(可能多个人同时通过这个门)，导致记录人的名字和地址时就会出现混乱。如何解决呢？ 其实，我们只要确保某一时刻只能有一个人通过这个门，问题就解决了。我们可以考虑使用Single Thread Execution模式。

线程安全的门：

public class SafeGate {
    private int counter = 0;
    private String name = "nobody";
    private String address = "nowhere";
    public synchronized void pass(String name ,String address){
        this.counter++;
        this.name = name;
        this.address = address;
        check();
    }

    public synchronized String toString(){
        return "NO."+counter+":"+name+", "+address;
    }

    private void check() {
        if (name.charAt(0) != address.charAt(0)){
            System.out.println("*****borken******"+toString());
        }
    }
}

其他的不用改变。

运行结果：

aaa is ready....
bbb is ready....
ccc is ready....

3.synchronized的作用
synchronized方法能够确保该方法同时只能由一个线程执行

三，SingleThreadExecution模式中的登场角色
SharedResource资源：可以被多个线程访问的类，包含很多方法，分为两类
安全方法：多个线程同时访问也没有关系
不安全方法：多个线程访问出现问题，必须加以保护
SingleThreadExecution模式会保护不安全的方法，使其同时只能由一个线程访问
临界区：只允许单个线程执行的程序范围

四，什么时候使用SingleThreadExecution模式？
1.多线程时
2.多个线程访问时：当ShareResource角色的实例有可能被多个线程同时访问时
3.状态有可能发生变化时：ShareResource角色的状态发生变化
4.需要确保安全性时：

五，生存性与死锁
1.在使用SingleThreadExecution模式时，会存在发生死锁的危险
2.死锁是指两个线程分别持有着锁，并相互等待对方释放锁的现象。
3.发生死锁条件：
存在多个SharedResource角色
线程在持有某个SharedResource角色的锁的同时，还去获取其他SharedResource角色的锁
获取SharedResource角色的锁的顺序并不固定

解决：只要破坏上面条件中的一个，就可以防止死锁发生了。

4.死锁的例子：

比如，有两个人A和B一起吃一份意大利面，但是桌子上只有一把勺子和一把叉子。吃面必须要同时用勺子和叉子。

假如A先拿到了勺子，而这时B拿到了叉子。这是会出现什么情况？

拿到勺子的A一直等着B放下叉子

拿到叉子的B一直等着A放下勺子

而他们会一直僵持下去，对应到程序中，就是两个线程分别持有锁，并等待对方释放锁。导致程序无法运行，这就是死锁

5.用代码来实现：

/**
 * 用餐工具
 */
public class Tool {

    private final String name;
    public Tool(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return "["+name+"]";
    }
}

public class EaterThread extends Thread {
    private String name;
    private final Tool lefthand;

    private final Tool righthand;

    public EaterThread(String name,Tool lefthand,Tool right){
        this.name = name;
        this.lefthand = lefthand;
        this.righthand = right;
    }

    @Override
    public void run() {
        while (true){
            eat();
        }
    }

    public void eat(){
        synchronized (lefthand){
            System.out.println(name+" takes up "+lefthand+" (left).");
            synchronized (righthand){
                System.out.println(name+ " takes up "+righthand +" (right).");
                System.out.println(name+ " is eating now.....");
                System.out.println(name +"puts down "+righthand+" (right).");
            }
            System.out.println(name+ "puts down "+lefthand+" (left).");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("test.....");
        //创建吃饭的工具
        Tool spoon = new Tool("Spoon");
        Tool fork = new Tool("Fork");
        //两个人抢夺工具吃饭
        new EaterThread("Alice",spoon,fork).start();
        new EaterThread("Bobby",fork,spoon).start();
    }
}

运行结果： 两个人分别持有锁，互相等待对方释放锁

Bobby takes up [Fork] (left).
Alice takes up [Spoon] (left).

6.解决：

方法一：A和B以相同的顺序拿餐具

public class Test {
    public static void main(String[] args) {
        System.out.println("test.....");
        //创建吃饭的工具
        Tool spoon = new Tool("Spoon");
        Tool fork = new Tool("Fork");
        //两个人抢夺工具吃饭，相同的顺序拿餐具
        new EaterThread("Alice",spoon,fork).start();
        new EaterThread("Bobby",spoon,fork).start();
    }
}

方法二： 勺子和叉子成对拿取，那就只用一把锁就可以了。

public class Tool {

    private final String name;
    public Tool(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return "["+name+"]";
    }
}

public class Pair {
    private final Tool lefthand;
    private final Tool righthand;
    public Pair(Tool lefthand, Tool righthand) {
        this.lefthand = lefthand;
        this.righthand = righthand;
    }

    @Override
    public String toString() {
        return "Pair{" +
                "lefthand=" + lefthand +
                ", righthand=" + righthand +
                '}';
    }
}

public class EaterThread extends Thread {
    
    private String name;
    private final Pair pair;

    public EaterThread(String name,Pair pair){
        this.name = name;
        this.pair = pair;

    }
    @Override
    public void run() {
        while (true){
            eat();
        }
    }
    public void eat(){
        synchronized (pair){
            System.out.println(name+" takes up "+pair+" .");
            System.out.println(name+ " is eating now.....");

            System.out.println(name+ "puts down "+pair+" .");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("test.....");
        //创建吃饭的工具
        Tool spoon = new Tool("Spoon");
        Tool fork = new Tool("Fork");
        Pair pair = new Pair(spoon,fork);
        //两个人抢夺工具吃饭
        new EaterThread("Alice",pair).start();
        new EaterThread("Bobby",pair).start();
    }
}

六，临界区大小和性能
SingleThreadExecution模式降低性能的原因：
1.获取锁花费时间
进入synchronized方法时，线程需要获取对象的锁，这个处理花费时间。若SharedResource角色的数量减少了，那么获取锁的数量减少，花费时间就会减少
2.线程冲突引起的等待
当线程A执行临界区的代码时，其他线程想要进入临界区的线程会阻塞，这称之为线程冲突。若尽可能缩小临界区的范围，可以减少线程冲突的概率。

七，Before/After模式
1.synchronized语法
synchronized(this){
    ....
}
上面的语法可以看作在 { 处获取锁，在 } 处释放锁。
2.显示处理锁
void method(){
    lock();//加锁
     ...
    unlock();//解锁
}

缺点：如果在lock方法和unlock方法之间存在return，那么锁就无法释放了。当lock和unlock之间抛出异常，锁也无法释放。而synchronized无论是return
    还是抛出异常，都一定能够释放锁。
3.解决：
我们想在调用lock()后，无论执行什么操作，unlock()都会被调用，我们可以使用finally来处理
void method(){
    lock();
    try{
        ...
    }finally{
        unlock();
    }
}

finally的这种用法是Before/After模式(事前/事后模式)的实现方法之一。

八，思考
使用synchronized时思考：
synchronized在保护什么
其他地方也妥善保护了吗
以什么单位保护
使用哪个锁保护
2.原子操作
从多线程观点来看，这个synchronized方法执行的操作是不可分割的操作，可以看成是原子操作

九，计数信号量和Semaphore类

Single Thread Execution模式用于确保某个区域只能由一个线程执行。如果我们想让某个区域最多能由N个线程执行，该如何实现？

java.util.concurrent包提供了表示计数信号量的Semaphore类。 可以用来控制并发数量

public class SemaphoreTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore sp = new Semaphore(3);
        for (int i = 0; i < 10; i++) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        //拿信号灯
                        sp.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程"+Thread.currentThread().getName()+
                    "进入，当前已经有"+(3-sp.availablePermits())+"个并发");
                    try {
                        Thread.sleep((long) (Math.random()*10000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //处理业务
                    try {
                        System.out.println("处理业务中.......");

                    }finally {
                        System.out.println("线程"+Thread.currentThread().getName()+"即将离开");
                        //释放信号灯
                        sp.release();
                    }
                    System.out.println("线程"+Thread.currentThread().getName()+
                            "已离开，当前有"+(3-sp.availablePermits()+"个并发"));
                }
            };
            executorService.execute(runnable);
        }
    }
}

当Semaphore sp = new Semaphore(1);只有一个信号灯时，作用相当于synchronized

sp.acquire和sp.release中间的代码最多允许N个线程同时访问

十，Mutex

Mutex是Mutual Exclusion(互斥)的缩写，使用Mutex类可以完成synchronized的功能。像Mutex类这样执行互斥处理的机制称为Mutex。

 1.自己实现一个Mutex类

public class UserThread extends Thread{
    
    private final MutexGate gate;
    private final String myName;
    private final String myAddress;


        public UserThread(MutexGate gate, String myName,String myAddress){
        this.gate = gate;
        this.myName = myName;
        this.myAddress = myAddress;
    }


    @Override
    public void run() {
        System.out.println(myName+" is ready....");
        while (true){
            gate.pass(myName,myAddress);
        }
    }
}

public class MutexGate {

    private int counter =0;
    private String name = "Nobody";
    private String adress = "Nowhere";
    private final Mutex mutex = new Mutex();

    public void pass(String name,String address){
        mutex.lock();
        try {
            this.counter++;
            this.name = name;
            this.adress = address;

        }finally {
            mutex.unlock();
        }
    }

    public String toString(){
        String s = null;
        mutex.lock();
        try {
            s = "NO."+counter+": "+name+", "+adress;
        }finally {
            mutex.unlock();
        }
        return s;
    }

    public void check(){
        if(name.charAt(0)!= adress.charAt(0)){
            System.out.println("*******broken+++++"+toString());
        }
    }

}

public final class Mutex {

    private boolean busy = false;
    public synchronized void lock(){
        while (busy){
            try {
                wait();
            }catch (InterruptedException e){

            }
        }
    }

    public synchronized void unlock(){
        busy = false;
        notifyAll();
    }
}

public class Test {

    public static void main(String[] args) {
       
        MutexGate gate = new MutexGate();
        new UserThread(gate,"aaa","aa").start();
        new UserThread(gate,"bbb","bb").start();
        new UserThread(gate,"ccc","cc").start();
    }
}

 2.问题：

从Mutex类中可以分析：

(1,一个线程不能重入

假如某一个线程连续调用两次lock方法，当第二次调用时，由于busy字段已经变为true，所以会执行wait。相当于自己把自己所在了外面

(2，任何人都可以unlock

即使线程自己没有调用lock方法，也能调用unlock方法。相当于不是自己上的锁，自己也可以打开一样

3.改良Mutex

public final class MutexPlus {
    private long locks = 0;//记录当前锁的个数 (锁的个数 = lock的调用次数 - unlock的调用次数)
    private Thread owner = null;//记录当前线程 (把调用lock方法的线程赋值给owner)
    public synchronized void lock(){
        Thread me = Thread.currentThread();
        while (locks>0 && owner != me){
            try {
                wait();
            }catch (InterruptedException e){
                
            }
        }
        assert locks ==0 || owner ==me;//断言，显式地表达此处肯定可以成立的条件
        owner = me;
        locks++;
    }
    
    public synchronized void unlock(){
        Thread me = Thread.currentThread();
        if (locks ==0 || owner != me){
            return;
        }
        assert locks > 0 || owner == me;
        locks--;
        if (locks == 0){
            owner =null;
            notifyAll();
        }
    }
    
}

4.使用java并法包提供的类

Lock lock = new ReentrantLock();
        lock.lock();
        //......
        lock.unlock();