java多线程学习笔记（二）多线程的同步

一、线程同步的原因

Java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。
实际例子：当两个人对一个银行账户进行取钱操作时，进入界面后，他们都可以看到余额有100元，如果不进行同步的话，则会发生两个人都能够取款100的现象，导致数据发生错误。

二、同步的五种方法

1、同步方法： 有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

//代码格式：
    public synchronized void save(){}

注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。

2、同步代码块： 即有synchronized关键字修饰的语句块，被该关键字修饰的语句块会自动被加上内置锁，从而实现同步。

//代码格式： 
    synchronized(object){ 
    }

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

3.使用特殊域变量(volatile)实现线程同步

• volatile关键字为域变量的访问提供了一种免锁机制
• 使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新
• 因此每次使用该域就要重新计算，而不是使用寄存器中的值
• volatile不会提供任何原子操作，它也不能用来修饰final类型的变量

//代码格式
	private volatile int account = 100;

4、使用重入锁实现线程同步： 在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。 ReentrantLock类是可重入、互斥、实现了Lock接口的锁，它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。

ReenreantLock类的常用方法有：

ReentrantLock() : 创建一个ReentrantLock实例 ；
lock() : 获得锁 ；
unlock() : 释放锁；

 //代码示例
	private  int count = 0;// 账户余额
	
	//需要声明这个锁
    private Lock lock = new ReentrantLock();
 
	// 存钱
	public void addMoney(int money) {
		lock.lock();//上锁
		try{
		count += money;
		System.out.println(System.currentTimeMillis() + "存进：" + money);
		
		}finally{
			lock.unlock();//解锁
		}
	}

注意： 如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 。如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁 。

5、使用局部变量实现线程同步： 如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本， 副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

ThreadLocal 类的常用方法：

ThreadLocal() : 创建一个线程本地变量
get() : 返回此线程局部变量的当前线程副本中的值
initialValue() : 返回此线程局部变量的当前线程的"初始值"
set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

三、死锁

定义: 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情况，某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题；

发生条件：

• 互斥条件：一个资源每次只能被一个进程使用。
• 请求与保持条件：一个进程因请求资源而阻塞时，对以获得的资源保持不放。
• 不剥夺条件：进程以获得的资源，在未使用完之前，不能强行剥夺。
• 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

避免死锁：

1. 破坏请求与保持条件： 一次性分配所有资源，这样就不会再有请求了；
2. 破坏不剥夺条件： 即当某进程获得了部分资源，但得不到其它资源，则释放已占有的资源；
3. ** 破坏循环等待条件：** 系统给每类资源赋予一个编号，每一个进程按编号递增的顺序请求资源，释放则相反（按照某个特定顺序申请资源）

四、多线程通信

1、wait/notify 机制

（1）wait()：让当前线程 (Thread.concurrentThread() 方法所返回的线程) 释放对象锁并进入等待（阻塞）状态。
（2）notify()：唤醒一个正在等待相应对象锁的线程，使其进入就绪队列，以便在当前线程释放锁后竞争锁，进而得到CPU的执行。
（3）notifyAll()：唤醒所有正在等待相应对象锁的线程，使它们进入就绪队列，以便在当前线程释放锁后竞争锁，进而得到CPU的执行。

public class Test {
    public static Object object = new Object();
 
    public static void main(String[] args) throws InterruptedException {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();
 
        thread1.start();
 
        Thread.sleep(2000);
 
        thread2.start();
    }
 
    static class Thread1 extends Thread {
        @Override
        public void run() {
            synchronized (object) {
                System.out.println("线程" + Thread.currentThread().getName()
                        + "获取到了锁...");
                try {
                    System.out.println("线程" + Thread.currentThread().getName()
                            + "阻塞并释放锁...");
                    object.wait();
                } catch (InterruptedException e) {
                }
                System.out.println("线程" + Thread.currentThread().getName()
                        + "执行完成...");
            }
        }
    }
 
    static class Thread2 extends Thread {
        @Override
        public void run() {
            synchronized (object) {
                System.out.println("线程" + Thread.currentThread().getName()
                        + "获取到了锁...");
                object.notify();
                System.out.println("线程" + Thread.currentThread().getName()
                        + "唤醒了正在wait的线程...");
            }
            System.out
                    .println("线程" + Thread.currentThread().getName() + "执行完成...");
        }
    }
}