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

男娘i 2022-11-17 10:28 264阅读 0赞

## 一、线程同步的原因 ##

> 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() + "执行完成...");
            }
        }
    }