Java高并发编程详解系列-单线程执行设计模式

矫情吗；* 2021-12-03 02:49 346阅读 0赞

### 引言 ###

> 首先介绍的这个技术有一个比较高大尚的英文名字叫做Single Thread Execution也就是说在同一时刻只能有一个线程访问共享资源，也就是说共享资源同一时间只能被一个线程访问，而这个共享资源就采用的排他的方式只要一个线程抢占资源就只有一个线程进行访问。

#### 独木桥 ####

什么是独木桥？就是一根木头，这根木头一次只能支持一个人通过。如果有一个人在独木桥上其他人就不能上这个独木桥。我们把这类似于这种模式模型的东西称为独木桥。

#### 线程安全独木桥问题 ####

首先我们来模拟一个线程不安全的场景，也就是说独木桥支持多个人通过。

public class Single_plankBridge { 
        private int count = 0;
    
        private String  boardingPass = "null";
    
        private String idCard = "null";
    
        public void pass(String boardingPass,String idCard){ 
            this.boardingPass = boardingPass;
            this.idCard = idCard;
            this.count++;
            check();
        }
    
        private void check() { 
            if (boardingPass.charAt(0)!=idCard.charAt(0)){ 
                throw new RuntimeException("====Exception===="+toString());
            }
        }
        
        public String toString(){ 
            return "The "+count+" passengers, boardingPass= ["+boardingPass+"],idCard ["+idCard+"]";
        }
    }

首先我们看到这个独木桥提供了一个pass方法，当用户进行认证之后调用check进行检查检查完成之后就可以通过独木桥。

public class Single_plankBridgeTest { 
        static class Passengers extends Thread{ 
            private Single_plankBridge single_plankBridge;
    
            private final String idCard;
    
            private final String boardingPass;
    
            public Passengers(Single_plankBridge single_plankBridge, String idCard, String boardingPass) { 
                this.single_plankBridge = single_plankBridge;
                this.idCard = idCard;
                this.boardingPass = boardingPass;
            }
    
            @Override
            public void run() { 
                while (true){ 
                    single_plankBridge.pass(boardingPass,idCard);
                }
            }
        }
        public static void main(String[] args) { 
            final Single_plankBridge single_plankBridge = new Single_plankBridge();
            new Passengers(single_plankBridge,"A123456","AF123456").start();
            new Passengers(single_plankBridge,"B123456","BF123456").start();
            new Passengers(single_plankBridge,"C123456","CF123456").start();
        }
    }

这里我们会发现看起来每个用户的身份信息的首字母都是一样的，但是运行起来却出现了错误，每次的运行效果都不一样。那么为什么会出现这样的效果呢？

Exception in thread "Thread-0" Exception in thread "Thread-1" java.lang.RuntimeException: ====Exception====The 1113 passengers, boardingPass= [CF123456],idCard [C123456]
    	at com.example.charp16.Single_plankBridge.check(Single_plankBridge.java:25)
    	at com.example.charp16.Single_plankBridge.pass(Single_plankBridge.java:20)
    	at com.example.charp16.Single_plankBridgeTest$Passengers.run(Single_plankBridgeTest.java:26)
    java.lang.RuntimeException: ====Exception====The 896 passengers, boardingPass= [BF123456],idCard [B123456]
    	at com.example.charp16.Single_plankBridge.check(Single_plankBridge.java:25)
    	at com.example.charp16.Single_plankBridge.pass(Single_plankBridge.java:20)
    	at com.example.charp16.Single_plankBridgeTest$Passengers.run(Single_plankBridgeTest.java:26)

#### 分析问题产生原因 ####

首先在多线程条件下调用pass方法如果传入的A对象的两个参数，那么这两个参数是确定就能实现一个校验。但是在执行过程中这两个变量的赋值操作可能会出现不一致，也就是说没有办法保证原子性操作。因为我们知道在CPU轮转的时候对于资源的利用是不一定的，加上Java的指令重排。很大程度上就导致了这些问题的产生。当然这里展示的是一个线程不安全的问题。下面来看一下线程安全的操作。

如果将pass方法变成如下的样子

public synchronized void pass(String boardingPass,String idCard){ 
            this.boardingPass = boardingPass;
            this.idCard = idCard;
            this.count++;
            check();
        }

在这个方法被修改之后，无论怎么运行都不会出现出错的情况。哪么为什么只有在pass方法前面加上synchronized关键字之后才不会出现报错的情况，我们会发现check方法在pass方法中执行，所以说不需要增加同步机制。这种模式就被称为是Single Thread Execution 。

在什么时候使用这种模式呢？

*  1、在多个线程访问共享资源的时候，被synchronized关键字修饰的方法具有排他性。
 *  2、多个线程对某个类的状态发生改变的时候。这个场景表示整个类作为共享资源存在。

在Java中经常被提及到的一个问题就是线程安全和线程不安全也就是非线程安全的类。所谓的线程安全的类就是指在多个线程同时操作这个类的时候不会引起数据不一致的问题，反之则是非线程安全的类。所以说在线程安全的类中经常会看到synchronized关键字。

#### 程序员吃面 ####

两个程序员吃面。这个时候，A程序员先拿起刀子等待B程序员放下叉子，B吃的时候等待A放下刀子。这个问题就是我定义的与给程序员吃面问题。

### 线程安全程序员吃面问题 ###

这个问题首先用代码来模拟看一下。

###### 定义一个餐具类 ######

public class Tableware { 
        private final String toolName;
    
        public Tableware(String toolName) { 
            this.toolName = toolName;
        }
    
        @Override
        public String toString() { 
            return "Tool: "+toolName;
        }
    }

###### 模拟吃面的动作 ######

public class EatNoodleThread extends Thread { 
        
        private final String name;
        
        private final Tableware leftTool;
        
        private final Tableware rightTool;
    
    
        public EatNoodleThread(String name, Tableware leftTool, Tableware rightTool) { 
            this.name = name;
            this.leftTool = leftTool;
            this.rightTool = rightTool;
        }
    
        @Override
        public void run() { 
            while (true){ 
                this.eat();
                
            }
        }
    
        private void eat() { 
            synchronized (leftTool){ 
                System.out.println(name + " take up "+leftTool+"(left)");
                synchronized (rightTool){ 
                    System.out.println(name + " take up "+rightTool+"(right)");
                    System.out.println(name + " is eating now.");
                    System.out.println(name + " put down "+rightTool+"(right)");
                }
                System.out.println(name + " put down "+leftTool+"(left)");
            }
        }
    }

##### 模拟程序员吃面 #####

public class Main { 
        public static void main(String[] args) { 
            Tableware fork = new Tableware("fork");
            Tableware knife = new Tableware("knife");
    
            new EatNoodleThread("A",fork,knife).start();
            new EatNoodleThread("B",knife,fork).start();
        }
    }

运行程序发现执行不了一段时间就会出现线程阻塞的问题。也就是说我们的程序员吃的太慢或者是太快了。

**怎么解决这问题？**  
  我们发下这问题中使用了Single Thread Execution模式，但是还是出现了多线程死锁的问题，主要的原因是两个交叉锁导致的，两个线程相互等待彼此的锁被释放。但是都以为对方已经释放。解决这个问题我们需要改用一副刀叉。

public class TablewarePair { 
        private final Tableware leftTool;
        private final Tableware rightTool;
    
        public TablewarePair(Tableware leftTool, Tableware rightTool) { 
            this.leftTool = leftTool;
            this.rightTool = rightTool;
        }
    
        public Tableware getLeftTool() { 
            return leftTool;
        }
    
        public Tableware getRightTool() { 
            return rightTool;
        }
    }

在来实现以下程序员吃面，这样的话每个程序员都有属于自己的一副餐具就不会导致你等我我等你的问题。

public class EatNoodleThreadH extends Thread { 
        private final String name;
        private final TablewarePair tablewarePair;
    
        public EatNoodleThreadH(String name, TablewarePair tablewarePair) { 
            this.name = name;
            this.tablewarePair = tablewarePair;
        }
    
        @Override
        public void run() { 
            while (true) { 
                this.eat();
            }
        }
    
        private void eat() { 
            synchronized (tablewarePair) { 
                System.out.println(name + " take up " + leftTool + "(left)");
    
                System.out.println(name + " take up " + rightTool + "(right)");
                System.out.println(name + " is eating now.");
                System.out.println(name + " put down " + rightTool + "(right)");
                System.out.println(name + " put down " + leftTool + "(left)");
            }
        }
    }

## 总结 ##

当然在编码界还有一个比较经典的例子就是哲学家吃面问题，这里涉及到的两个线程出现的死锁，哲学家吃面的问题涉及到的多个线程之间的死锁问题。多个线程出现访问同样的资源出现死锁的问题需要根据不同的场景涉及不同的解决方案。但是这些解决方案的核心是不变的就是涉及到同一时间只允许一个线程执行操作。