多线程进阶之二

一，关键字Synchronized

              我们为什么要线程同步呢？ 因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，跟我们预期有出入，比如下面的例子

类Task有一个静态的变量num，有一个add()方法

package com.remote3c.main;

public class Task {
	private static int num=0;
	
	public  void add(String name){
		num++;
		System.out.println(name +",你是第"+num+"个使用Task的线程");
	}
}

一个线程类

package com.remote3c.main;

import java.util.concurrent.TimeUnit;

public class MyThread implements Runnable {
	public Task task;
	public MyThread(Task task) {
		super();
		this.task = task;
	}
	@Override
	public void run() {
		task.add(Thread.currentThread().getName());
		try {
			TimeUnit.MILLISECONDS.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

Test类

package com.remote3c.main;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ExecutorService exec =Executors.newCachedThreadPool();
		Task task = new Task();
		for(int i = 0;i<6;i++){
			exec.execute(new MyThread(task));
		}
		exec.shutdown();
	}

}

new 出5个线程，同时访问同一个对象task的add()方法，我们想要的结果是1，2,3这样按顺序递增的情况，可事实却是这样的

pool-1-thread-2,你是第1个使用Task的线程
pool-1-thread-1,你是第2个使用Task的线程
pool-1-thread-6,你是第4个使用Task的线程
pool-1-thread-4,你是第3个使用Task的线程
pool-1-thread-3,你是第5个使用Task的线程
pool-1-thread-5,你是第6个使用Task的线程

这种混乱的结果跟我们想要的结果相去甚远，究其原因是因为多个线程同时访问共享资源（num）,没有先后顺序才导致的混乱局面，怎么才能保证多个线程同时访问一个资源（共享资源）时，有序的，正确的进行呢，那就是在一个线程访问共享资源时其他的都得等它结束才能访问，就是给共享资源加锁，java中用关键字synchronized来实现同步

只需要在add()方法上加上这个关键字，如下

package com.remote3c.main;

public class Task {
	private static int num=0;
	
	public synchronized void add(String name){
		num++;
		System.out.println(name +",你是第"+num+"个使用Task的线程");
	}
}

输出结果 就会是我们想要的那种

pool-1-thread-1,你是第1个使用Task的线程
pool-1-thread-2,你是第2个使用Task的线程
pool-1-thread-4,你是第3个使用Task的线程
pool-1-thread-6,你是第4个使用Task的线程
pool-1-thread-5,你是第5个使用Task的线程
pool-1-thread-3,你是第6个使用Task的线程

二，原子性和可视性

 1 原子性

      原子是发生化学反应的最小单位，顾名思义即为不可再拆分。原子操作是不能被线程中断机制中断的操作，一旦操作开始，则它一定在可能的切换到其他线程之前执行完毕。简而言之就是不能被中断的操作，如赋值或return。

  2 可视性

    （1）在多核处理器中，如果多个线程同时对一个变量进行操作，这些线程可能被分配到不同的CPU中运行。由于编译器会对代码进行优化，当某个线程要对这个变量进行操作时，为了提高操作速度，这个线程所在的CPU会从主存中复制这个变量到自己的缓存中，等操作完成后再存储到主存中。因此不同的线程对应的这个变量就有不同的状态。（注：在单核处理器中也存在可视性问题）

    （2） 变量的可视性：假设有两个线程T1和T2分别被安排到了两个不同的CPU中(cpu1、cpu2)，则T1和T2对变量a的修改互不可视，如T1对a进行修改之后，只是对cpu1缓存中的a运行修改，没有立即被写入到主存中，因此当线程T2再对a进行操作时，操作的并不是被线程T1修改后的新值。此时线程T1和线程T2对于变量a是互不可视的。

    （3）不可视性产生的问题：多个线程对某个变量的操作互不可视，可能造成某些操作被覆盖，产生错误的结果。如对于变量a，线程T1和线程T2都对其进行a++操作，T1操作a++后并没有及时地将结果写入到主存中去，而是继续执行其它对a的操作，当T2再执行a++操作后，它并没有发现a的值已被线程T1修改，这样就由于a的值没有被及时更新而产生错误。

三、死锁

           死锁不是我们想见的，可是有时候它偏偏又会出现，所以为了防止它，我们有必要了解它，从而远离它，产生死锁的原因有很多，最常见的是同时锁住两个对象，而另外一个锁也同时锁住了这两个对象，又互有先后，就会出现死锁，经典的死锁是哲学家吃饭的问题，下面我们来看一个死锁

package com.remote3c.main;

import java.util.concurrent.TimeUnit;

public class DeadLock implements Runnable {
	public int flag ;
	static Object ob1 =new Object() ,ob2 =new Object();
	
	public void run() {
		
		if(flag==1){
			System.out.println("flag = "+flag);
			synchronized (ob1) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			
				synchronized (ob2) {
					System.out.println("你是第一个线程flag =1");
				}
			
			}
		}

		
			if(flag==2){
				System.out.println("flag = "+flag);
				synchronized (ob2) {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				
					synchronized (ob1) {
						System.out.println("你是第二个线程flag =2");
					}
				}
			}
   }

}

package com.remote3c.main;

public class Main {
	public static void main(String[] args){
		DeadLock d1=new DeadLock();
		DeadLock d2=new DeadLock();
		d1.flag=1;
		d2.flag=2;
		new Thread(d1).start();
		new Thread(d2).start();
	}
}

从本例中可以看出 两个线程d1和d2，有flag区分开来执行不同的方法块，flag=1时 锁住ob1,并且sleep()一秒钟，等待锁住ob2就能输出“你是第一个线程flag =1”，

而此时另外一个线程d2,执行flag=2的代码，锁住了ob2，再等待锁住ob1就能输出“你是第二个线程flag=2”了，可是很不幸，此时线程一锁住了ob1，在等ob2，而线程二锁住了ob2在等ob1，就这样一直等下去了，这种想象就叫做死锁。