java并发编程

 

一、线程基础

Thread类:

start():当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。

run():当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。

sleep(1000)：sleep相当于让线程睡眠，交出CPU，让CPU去执行其他的任务。
但是有一点要非常注意，sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。

yield()：调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。

join()：假如在main线程中，调用thread.join方法，则main方法会等待thread线程执行完毕或者等待一定的时间。如果调用的是无参join方法，则等待thread执行完毕，如果调用的是指定了时间参数的join方法，则等待一定的事件。

interrupt()：单独调用interrupt方法可以使得处于阻塞状态的线程抛出一个异常，也就说，它可以用来中断一个正处于阻塞状态的线程；interrupt方法不能中断正在运行中的线程，但是可以通过interrupt方法和isInterrupted()方法来停止正在运行的线程(不推荐，使用标志位替代)。

setDaemon()和isDaemon()：用来设置线程是否成为守护线程和判断线程是否是守护线程。
守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。

Runnable 接口:

Runnable只有一个抽象的run()方法，此方法是在运行时由JVM调用。

Runnable 接口可以被任何想要被一个线程运行的接口继承实现；继承 Runnable 接口的类必须有一个 run() 方法；
Runnable 接口被设计的目的是为那些当其处于活跃期时期望运行代码的对象提供一个公共的协议；处于活跃期简单的说就是一个线程已经启动但还没有结束
继承 Runnable 接口实现线程，不需继承 Thread；而将类本身作为 Thread 中的目标 target
Runnable 接口最好不要继承，除非开发者想要更好的扩展此接口的功能

synchronized：

可以在任意对象及方法上加锁，而加锁的这段代码称为"互斥区"或"临界区"

* 关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当做锁，
 * 所以代码中哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁（Lock），
 * 
 * 在静态方法上加synchronized关键字，表示锁定.class类，类级别的锁（独占.class类）。

使用synchronized代码块减小锁的粒度，提高性能

 

使用synchronized代码块加锁，如下：

public void method1(){
		synchronized (this) {	//加当前对象锁
			try {
				System.out.println("do method1..");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public void method2(){		//加类锁
		synchronized (ObjectLock.class) {
			try {
				System.out.println("do method2..");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	private Object lock = new Object();
	public void method3(){		//对任何对象加锁
		synchronized (lock) {
			try {
				System.out.println("do method3..");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

 一个线程想要执行synchronized修饰的方法里的代码步骤：
         1 、尝试获得锁
         2 、如果拿到锁，执行synchronized代码体内容；拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，
                     而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）

--------------------------------------------------------------------------------------------------------------------------------------------------------------------

t1和t2两个线程访问synchronized修饰的方法是同步访问，没有被synchronized修饰的方法是异步访问：

         t1线程先持有object对象的Lock锁，t2线程可以以异步的方式调用对象中的非synchronized修饰的方法
         t1线程先持有object对象的Lock锁，t2线程如果在这个时候调用对象中的同步（synchronized）方法则需等待，也就是同步

--------------------------------------------------------------------------------------------------------------------------------------------------------------

业务整体需要使用完整的synchronized，保持业务的原子性。例如get方法和set方法都需要加 synchronized修饰，保证原子性，防止出现脏读

---------------------------------------------------------------------------------------------------------------------------------------------------------------

synchronized（obj）,obj对象作为锁，在程序中改变锁对象使obj指向另一个实例，锁对象改变导致不能同步。但同一对象属性的修改不会影响锁的情况，例如对obj对象的某个属性赋值后，不会影响锁的情况

------------------------------------------------------------------------------------------------------------------------------------------------------------------

死锁问题，在设计程序时就应该避免双方相互持有对方的锁的情况，以下代码会死锁：线程t1获得锁lock1,线程t2获取lock2，然后线程t1又想要获得锁lock1,线程t2想要获得锁lock2造成死锁，如下死锁代码：

    private static Object lock1 = new Object();
	private static Object lock2 = new Object();

	@Override
	public void run() {
		if(tag.equals("a")){
			synchronized (lock1) {
				try {
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入lock1执行");
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (lock2) {
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入lock2执行");
				}
			}
		}
		if(tag.equals("b")){
			synchronized (lock2) {
				try {
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入lock2执行");
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (lock1) {
					System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入lock1执行");
				}
			}
		}
	}

-----------------------------------------------------------------------------------------------------

 

二、线程间通讯

wait()，notify()，notifyAll() ：

wait()、notify()、notifyAll() 都是Object的方法，需要配合synchronized关键字使用，wait()方法使线程等待，并且释放锁，notify()方法唤醒一个等待的线程，但是不释放锁，notifyAll()方法唤醒所有等待的线程。被notify()、notifyAll()方法唤醒的线程再次参与锁的竞争

volatile：

首先解释一下java内存模型如下：

Java内存模型规定了所有的变量都存储在主内存（Main Memory）中，此外每条线程还有自己的工作内存（Working Memory）。

线程的工作内存中保存了被该线程使用到的变量的主内存副本拷贝，线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，不能直接读写主内存中的变量。

并且，不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量值得传递均需要通过主内存来完成，线程、主内存、工作内存关系如下图：

Java语言提供了一种稍弱的同步机制，即volatile变量，用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。

在读写volatile类型的变量发生的过程如下：

• 第一：使用volatile关键字会强制将修改的值立即写入主存；
• 第二：使用volatile关键字的话，当线程2进行修改时，会导致线程1的工作内存中缓存变量的缓存行无效（反映到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存行无效）；
• 第三：由于线程1的工作内存中缓存变量的缓存行无效，所以线程1再次读取变量的值时会去主存读取。

　　在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。

总结volatile变量：

• 可见性（最重要的特性）。被volatile修饰的变量是共享的，是对所有线程都可见的，对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。
• 原子性：对任意(包括64位long类型和double类型)单个volatile变量的读/写具有原子性，另外任何复合操作都不能保证原子性，如a++，a = a+1, a = b

 

ThreadLocal：

为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单：在ThreadLocal类中有一个Map，用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值对应线程的变量副本。

示例：

public class ConnThreadLocal {

    //ThreadLocal 变量
	public static ThreadLocal<String> th = new ThreadLocal<String>();
	
	public void setTh(String value){
		th.set(value);
	}
	public void getTh(){
		System.out.println(Thread.currentThread().getName() + ":" + this.th.get());
	}
	
	public static void main(String[] args) throws InterruptedException {
		
		final ConnThreadLocal ct = new ConnThreadLocal();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				ct.setTh("张三");
				ct.getTh();
			}
		}, "t1");
		
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(1000);
					ct.getTh();
				} catch (I