本文共 8608 字，大约阅读时间需要 28 分钟。
目录
在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://aycti.baihongyu.com/