线程间通讯方式 & 哲学家死锁

offer 108

2014-5-16（周五）

1. Java 多线程编程时出现的泛型错误

java 使用了未经检查或者不安全的操作

只需要给使用的容器加上泛型就可以，博文来源

2. 昨天有一副图片可以表示线程间通讯方式：

1）下面给出《thinking in java》中的管道通讯程序：

import java.io.*;
import java.util.*;

class Sender extends Thread{
	private Random rand = new Random();
	private PipedWriter out = new PipedWriter();
	public PipedWriter getPipedWriter() {return out;}
	public void run(){
		while(true){
			for(char c='A';c <= 'z';c++){
				try{
					out.write(c);
					sleep(rand.nextInt(500));
				}
				catch(Exception e){
					throw new RuntimeException(e);
				}
			}
		}
	}
}

class Receiver extends Thread{
	private PipedReader in;
	public Receiver(Sender sender) throws IOException{
		in = new PipedReader(sender.getPipedWriter());
	}
	public void run(){
		try{
			while(true){
				System.out.println("Read: "+(char)in.read());
			}
		}catch(IOException e){
			throw new RuntimeException(e);
		}
	}
}

public class PipedIO{
	public static void main(String[] args) throws Exception{
		Sender sender = new Sender();
		Receiver receiver = new Receiver(sender);
		sender.start();
		receiver.start();
		new Timeout(4000,"Terminated");
	}
}

2）Java的锁和synchronized关键字属于内置的信号量机制，使用这两者的方式都属于信号量通信。

3）套接字顾名思义：socket与socketServer

3. 关于volatile关键字

在使用volatile替代锁的条件：

1. 对变量的写操作不依赖于当前值

2. 该变量没有包含在具有其他变量的不变式中

IBM的博文对volatile进行了讨论（2007年），个人读后的领略是：

锁（synchronized）具有：互斥性和可见性

volatile：只具有可见性，只读操作效率比锁高，但是对++操作符（读，写，存储）不具有原子性，原子性的就只有 赋值和返回（= 或者 return ** ）

4. 关于死锁

《thinking in java》里面关于Philosopher的java实现挺精彩（3rd，Page753，英文版，中文版503页），下面给出死锁的四个条件，需同时满足才能导致死锁：

1）互斥条件，资源至少有一个不能共享，哲学家问题是，一棍筷子只能被一个哲学家使用

2）一个进程必须持有资源等待获取另一个被别的进程持有的资源，一个哲学家拿着一根筷子等另一个哲学家的一根筷子

3）资源不能被进程抢占，哲学家是很有素质滴，他们不抢别人的筷子。

4）循环等待，每个哲学家左手拿着一根筷子等另一个人右手的那根筷子

书中破坏死锁的是条件4，最后一位哲学家取筷子的顺序是先右后左，所以其他哲学家总有一个能拿到右手的筷子，死锁就被破坏了。

5. 关于感想

读了《thinking in java》的第13章，感觉对于并发，《thinking in java》里面说到的也只是皮毛，以前那种快速把书看完的想法几乎都不见了，重要的是领略，关于java并发和特性有无限的知识，看完了这本书，能发觉的只是前面还有一个知识的海洋，所以如果是想进行工作，那么还是应该掌握写企业需要的知识，每天确定自己的路，相当重要。亲，加油。