多线程学习系列 - 1 - Single Threaded Execution Pattern

目录

多线程学习系列 - 1 - Single Threaded Execution Pattern

多线程学习系列 - 2 - Immutable Pattern

 

在android里面多线程是非常普遍的

之前工作中并不涉及太多多线程的问题，所以也就一直没有系统学习过

 

这个系列的学习选的书为《java多线程设计模式》-结城浩 著，博硕文化 译

一提到设计模式，大家可能有种种想法，但是不管大家怎么想，我希望您能先简单读读这本书

我觉得它讲的通俗易懂，例子也比较有代表性，分析的很全面，还有课后习题及答案

最重要的一点，它确实很实用，废话不多说了

 

学习过程中笔记也肯定会有些不严谨的地方，希望大家在踩我的时候能加上几句指导的话语，在此笔者感激不尽

 

书中最开始讲了一些简单的线程知识，这里也就不做整理了

 

书中以例子为主，我觉得效果还不错，所以我的笔记也以书中例子为主

 

第一章：Single Threaded Execution Pattern

考虑这样一个问题：

去某些公司面试的时候进出需要安检，一个门一次只能允许一个人通过，通过的时候工作人员对你进行身份识别。

如果多个人一起，那么工作人员所掌握的信息很有可能变得混乱。下面我们来看看工作人员的抱怨

 

假设有三个Alice，Boddy，Chris，他们分别来自Alaska，Brazil，Canada

那么我们先以一种简单的方式来做一个简单的检查，如果名字的首字母=国家的首字母，那么我们就认为检查通过

 

public static class Gate{
	private int counter = 0;
	private String name;
	private String address;
	
	public void pass(String name, String address){
		this.counter++;
		this.name = name;
		this.address = address;
		check();
	}
	
	private void check(){
		if(this.name.charAt(0) != this.address.charAt(0)){
			System.out.println("broken:" + toString());
		}
	}
	
	public String toString(){
		return "No. " + this.counter + ":" + this.name + "," + this.address;
	}
}

  大门对通过的人员进行信息记录并检查，如果出错则会打印错误信息，注意这里的pass方法可以改变Gate一些属性的状态

 

 

下面的类是捣乱的人

public static class UserClass extends Thread{
	private final Gate gate;
	private final String name;
	private final String address;
	
	public UserClass(Gate gate, String name, String address){
		this.gate = gate;
		this.name = name;
		this.address = address;
	}
	
	public void run(){
		while(true){
			gate.pass(this.name, this.address);
		}
	}
}

 这个人会不断反反复复的经过大门，同时告诉大门自己的信息

 

 

最后来看看程序运作

public static void main(String[] args) {
	Gate gate = new Gate();
	new UserClass(gate, "Alice", "Alaska").start();
	new UserClass(gate, "Boddy", "Brazil").start();
	new UserClass(gate, "Chris", "Canada").start();
}

 执行，结果让人很不满意

基本上马上就会有错误信息提示，log我就不贴了。。。

 

 

原因其实很简单，我觉得书中的表格不错

所以还是借来

 

 

线程Alice	线程Bruce	this.name的值	this.address的值
this.counter++;   this.name = name; this.address = address;   check();	this.counter++; this.name = name;     this.address = address; check();	(之前的值) "Boddy" "Alice" "Alice" "Alice" "Alice" broken...	(之前的值) (之前的值) (之前的值) "Alaska" "Brazil" "Brazil"

 

上面是其中一种情况

工作人员智商有些问题，它一次只能记住一个名字和地址

Alice和Boddy都来到了门前，Bruce告诉工作人员他的名字，

工作人员记录名字：boddy

Alice来凑热闹把自己的名字和地址告诉了工作人员，这时候工作人员记录名字：Alice，地址Alaska

Boddy呢，这人他给忘了。。。

然后Boddy又告诉他自己的地址，于是工作人员脑中是这样记录的：名字Alice，地址Brazil

然后Alice和Boddy都等着工作人员核对（check()），于是悲剧发生了，工作人员认为这两个人都在骗他，所以发出了警告

 

发生这种情况的原因是Alice和Boddy非要争抢过安检，如果安检门弄小点，让他们一次最多过来一个，那就不会发生这种情况了

在这个例子中，也就是说：gate的pass方法一次只让一个线程调用，不允许Alice正在pass中呢，别人再凑过来

 

很幸运，java中用synchronized关键字就可以保证一次只有一个线程来执行这个方法

修改后的代码

public static class Gate{
	private int counter = 0;
	private String name;
	private String address;
	
	public synchronized void pass(String name, String address){
		this.counter++;
		this.name = name;
		this.address = address;
		check();
	}
	
	private void check(){
		if(this.name.charAt(0) != this.address.charAt(0)){
			System.out.println("broken:" + toString());
		}
	}
	
	public synchronized String toString(){
		return "No. " + this.counter + ":" + this.name + "," + this.address;
	}
}

 这时候再运行，则不会再出差错了

上面的代码只是给pass方法和toString方法加上了synchronized关键字

上面pass前面说过了

那么toString为什么也加上了synchronized关键字，为什么check没有加（课后习题3）

首先解释check的问题

check是private的，所以只能gate自己访问的到，在外面无法被调用。

gate里面pass调用了它，因为pass已经加上了synchronized，所以没有必要再给check函数设置此关键字

 

关于toString，由于它是public的，所以在外面可以被访问。

如果现在Alice正在调用toString，this.name = Alice，此时Boddy执行pass方法，把address改掉了，这时候Alice继续执行toString，那么悲剧发生了

所以，toString加上synchronized是必要的，这样执行toString方法时就不会被pass函数干扰了

 

在这个例子原始状态中，打印到出错的log时候counter已经到1000+了，如何让程序更快的看的错误log呢

其实不难，延长pass方法即可

public void pass(String name, String address) {
    this.counter++;
    this.name = name;
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
    }
    this.address = address;
    check();
}

 pass方法执行时间变长了，出错的几率也就变高了（课后习题1）

 

 

关于Single Threaded Execution模式适用性，需要满足下面的条件：

1.多线程时

2.数据可被多个线程访问

3.状态可能改变

4.需要确保数据安全性

这些都很容易理解，不再加以解释

 

生命性与死锁

考虑下面的一种情况：

假设Alice和Boddy都是个吃货，他们打算享用意大利面，但是只有一套餐具：一把叉子一把汤匙

吃面的时候同时需要叉子和汤匙，Alice眼疾手快拿到了叉子，Boddy不甘示弱抢到了汤匙，这时候尴尬了

Alice等着Boddy放下汤匙，Boddy等着Alice放下叉子，然后他们就这么一直等下去，地老天荒，海枯石烂。。。

这时候就是所谓的死锁。

 

Single Threaded Execution满足那些条件时可能发生死锁呢？

1.具有多个参与者（SharedResource）

2.线程锁定一个SharedResource时，没有解除锁定就去锁定另一个SharedResource

3.获取SharedResource参与者的顺序不固定（和SharedResource参与者是对等的）

 

现在我们再看看吃货这个例子

1.多个参与者（SharedResource）相当于叉子和汤匙

2.Alice拿到了汤匙不放手就要去拿叉子

3.拿汤匙和叉子地位相同，不要求先拿谁

 

只要1,2,3其中一条被破坏了，那么就可以避免死锁的发生

下面用代码来描述这个例子（习题6）

餐具

public static class Tool{
	private final String name;
	
	public Tool(String name){
		this.name = name;
	}
	
	public String toString(){
		return "[" + name + "]";
	}
}

 

吃货

public static class EaterThread extends Thread{
	private String name;
	private Tool leftHand;
	private Tool rightHand;
	
	public EaterThread(String name, Tool leftHand, Tool rightHand){
		this.name = name;
		this.leftHand = leftHand;
		this.rightHand = rightHand;
	}
	
	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 ,yam yam!");
				System.out.println(name + " put down " + rightHand + "(right.)");
			}
			System.out.println(name + " put down " + leftHand + "(left.)");
 		}
	}
}

 

public static void main(String[] args) {
    Tool spoon = new Tool("Spoon");
    Tool fork = new Tool("Fork");
    new EaterThread("Alice", spoon, fork).start();
    new EaterThread("Bobby", fork, spoon).start();
}

 看看运行情况，果然他们没吃几口，就停住了

Alice takes up [Spoon](left.)
Alice takes up [Fork](right.)
Alice is eating now ,yam yam!
Alice put down [Fork](right.)
Alice put down [Spoon](left.)
Alice takes up [Spoon](left.)
Bobby takes up [Fork](left.)

 

原因也很简单，一个人先拿起一个餐具不放（synchronized (leftHand)）的同时去拿另一个餐具，在他还没拿起来下一个餐具的时候，另一个人也打算eat，执行到这里的时候synchronized (leftHand)，因为两个人拿到的是不同的餐具，所以leftHand指向不同的对象，代码并不相互影响所以程序继续执行，然后他们就发现无法获得另一把餐具，因为在对方手里

 

之前提到了Single Threaded Execution发生死锁的3个要素

我们来挨个尝试一下

首先破坏

1.具有多个参与者（SharedResource）

那么我们只提供叉子好了，你们都用一只手，有个吃相

public static class EaterThread extends Thread{
	private String name;
	private Tool hand;
	
	public EaterThread(String name, Tool hand){
		this.name = name;
		this.hand = hand;
	}
	
	public void run(){
		while(true){
			eat();
		}
	}
	
	public void eat(){
		synchronized (hand) {
			System.out.println(name + " takes up " + hand);
			System.out.println(name + " is eating now ,yam yam!");
			System.out.println(name + " put down " + hand);
		}
	}
}

public static void main(String[] args) {
    Tool fork = new Tool("Fork");
    new EaterThread("Alice",  fork).start();
    new EaterThread("Bobby", fork).start();
}

 

如果破坏

2.线程锁定一个SharedResource时，没有解除锁定就去锁定另一个SharedResource

习题答案的方式实际和上面差不多，如果只有一个工具那就不会打架了

下面引入一个新的类Pair

public static class Pair{
	private Tool rightHand;
	private Tool leftHand;
	public Pair(Tool rightHand, Tool leftHand){
		this.rightHand = rightHand;
		this.leftHand = leftHand;
	}
	
	public String toString(){
		return "[" + leftHand + "," + rightHand + "]";
	}
}

 改造EaterThread

public static class EaterThread extends Thread{
	private String name;
	private Tool leftHand;
	private Tool rightHand;
	
	public EaterThread(String name, Pair pair){
		this.name = name;
		this.leftHand = pair.leftHand;
		this.rightHand = pair.rightHand;
	}
	
	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 ,yam yam!");
				System.out.println(name + " put down " + rightHand + "(right.)");
			}
			System.out.println(name + " put down " + leftHand + "(left.)");
		}
	}
}

 

public static void main(String[] args) {
    Tool spoon = new Tool("Spoon");
    Tool fork = new Tool("Fork");
    Pair p = new Pair(spoon, fork);
    new EaterThread("Alice", p).start();
    new EaterThread("Bobby", p).start();
}

 

这样他们也会交替的你吃一会我吃一会了

 

最后来破坏

3.获取SharedResource参与者的顺序不固定（和SharedResource参与者是对等的）

这只需要让他们按着相同的顺序来拿餐具即可

public static void main(String[] args) {
    Tool spoon = new Tool("Spoon");
    Tool fork = new Tool("Fork");
    new EaterThread("Alice", spoon, fork).start();
    new EaterThread("Bobby", spoon, fork).start();
}

 

笔记截图

 

至此这章内容就基本结束了

在书中的进阶说明里有一些关于synchronized的讨论

关于synchronized，我们需要思考

1.synchronized在保护什么

确定下来要保护的内容之后，要思考一下，其他地方有没有需要保护的，为什么

2.该以什么单位保护

比如我需要同时获得叉子和汤匙，这是一个完整的动作不能分割（当然也不是不能分割，分割后就会出现大眼瞪小眼的情况），那么

public synchronized void setName(String name){
	this.name = name;
}

public synchronized void setAddress(String address){
	this.address = address;
}

 这种形式就没有意义，并不安全（要把它当做一整体，可以像Pair那样封装一下）

3.获取谁的锁定来保护

调用synchronized方法是获得实例this的锁定，如果实例不同，锁也就不同，所以不同实例可同时执行synchronized的相同的方法。使用synchronized块的时候也是需要获得对象的锁，所以需要考虑好获得谁的锁。书中给出一个比喻：获得错误的锁就好比想要保护自己的家，却锁上了邻居的门

 

 

转贴请保留以下链接

本人blog地址

http://su1216.iteye.com/

http://blog.csdn.net/su1216/