Java并发编程实战笔记一（线程带来的风险）

1.1 线程带来的风险

     虽然Java提供了相应的语言和类库，以及一种明确的跨平台模型的并发应用程序，但同时也提高了对开发人员的技术要求，因为程序中线程无处不在，所以，必须了解线程方面的内容。

 

1.1.1 安全性问题

     线程安全性可能是非常复杂的，在没有同步的情况下，多个线程中的操作顺序是不可预测的，甚至每次的结果存在不确定性。

下面这段示例代码Counter类中将产生一个整数序列值，在单线程环境中，这个类能正常工作，但在多线程环境中测试不能。

public class Counter {

	private int counter = 0;
	
	public int get() { return counter; }
	
	public int increment() {
		return counter++;
	}
}

Counter类的问题在于，如果执行时机不对，多个线程同时在调用increment时会得到相同的值。虽然递增运算counter++看上去是单个操作，但事实上它包含三个独立的操作：读取counter，将counter+1，并将计算结果写入。因此多个线程可能同时执行读操作，读取到一样的值，并都将这个值加1。

线程A ->  counter=9 -> 9+1=10  -> counter=10

线程B ->  counter=9 -> 9+1=10  -> counter=10

由于多个线程要共享相同的内存地址空间，并且是并发运行，因此它们可能会访问或修改其他线程正在使用的变量。通过将increment修改为一个同步方法，可以修复Counter类的错误。

synchronized：Java语言关键字（保证原子性和可见性），原子性意味着同一时刻保证只有一个线程去执行被synchronized锁定的代码；可见性意味着当一个线程更新了共享数据时对其他线程可见。

 

public synchronized int increment() {
        return counter++;
    }

 

1.1.2 活跃性问题

     活跃性问题的形式之一就是无意中造成的无限循环，从而使循环之后的代码无法得到执行。例如，如果线程A在等待线程B释放其持有的资源，而线程B永远都不释放该资源，那么A就会永久的等待下去。包括（死锁、饥饿以及活锁），与大多数并发现错误一样，导致活跃性问题的错误同样是难以分析的。

     死锁最简单的情形：线程A持有对象X的独占锁，并在等待对象Y的锁，而线程B持有对象Y的独占锁，却在等待对象X的锁。下面将以代码示例演示一下死锁的情形：

public static void main(String[] args) {
		
		DeadLock dl = new DeadLock();
		Thread t1 = new Thread(dl,"A");
		Thread t2 = new Thread(dl,"B");
		t1.start();
		t2.start();
		
	}
	private static class DeadLock implements Runnable {
		Object X = new Object();
		Object Y = new Object();
		@Override
		public void run() {
			if (Thread.currentThread().getName().equals("A")) {
				synchronized (X) { // 线程A 持有X对象
					System.out.println("X " + Thread.currentThread().getName());
					synchronized (Y) { // 线程A获取未释放的Y对象
						System.out.println(Thread.currentThread().getName());
					}
				}
			} else {
				synchronized (Y) { // 线程B 持有Y对象
					System.out.println("Y " + Thread.currentThread().getName());
					synchronized (X) { // 线程B获取未释放的X对象
						System.out.println(Thread.currentThread().getName());
					}
				}
			}
			System.out.println("---------------------------end");
		}
	}

上面的代码永远都不会执行打印语句。

 

1.1.3性能问题

　　在良好的并发应用程序中，线程能提升程序的性能，但无论如何，线程总会代理某种程度的运行开销。在多线程程序中，当线程调度器临时挂起线程并转运而运行的另一个线程时，就会频繁的上线文切换操作（Context　Swith），这种操作将带来极大的开销：保存和恢复执行上下文，丢失局部性，并且CPU时间将更多的花在线程调度而不是程序运行上。当线程共享数据时，必须使用同步机制，而这些机制往往会抑制某些编译器优化，使内存缓存区中的数据无效，以及增加共享内存总线的同步流量。所有的这些因素都将带来额外的性能开销。

例如：sleep／wait／notify这类方法的操作。