多线程（二）线程安全 | 线程同步

1.线程安全问题概述

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果是一样的，而且其他的变量的值也和预期一样，就是线程安全的。

我们通过一个案例，演示线程的安全问题：

案例代码实现：

//模拟卖票案例
class RunnableImpl implements Runnable{
	//定义一个多线程共享的资源
	private int ticket = 30;
	
        //设置线程任务：卖票
	@Override
	public void run(){
		while(true){
			if(ticket>0){  
		                try {
                                       Thread.sleep((int)Math.random()*10);
                                    } catch (InterruptedException e) {
                                     e.printStackTrace();}
		              System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
			      ticket--;
			   
			}
		}
	}
	
	public static void main(String[] args) {
		//创建Runnable接口的实现类对象
		RunnableImpl r1 = new RunnableImpl();
		//创建Thread对象，构造方法中传递Runnable接口的实现类对象
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r1);
		Thread t3 = new Thread(r1);
		//调用start方法开启多线程
		t1.start();
		t2.start();
		t3.start();
		
	}
}

运行结果：

分析：出现了线程安全问题，卖票出现了重复的票和不存在的票

原因：

 2.线程同步

2.1 同步代码块

synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式：

synchronized(锁对象){

     可能会出现线程安全问题的代码（访问了共享数据的代码）

}

注意：

• 同步代码块中的锁对象，可以使用任意的对象
• 但是必须保证多个线程使用的锁对象是同一个
• 锁对象作用：把同步代码块锁住，只让一个线程在同步代码块中执行

使用同步代码块实现线程同步的代码：

//模拟卖票案例
class RunnableImpl implements Runnable{
	//定义一个多线程共享的资源
	private int ticket = 30;
	
	//同步锁
	Object obj =new Object();
	
    //设置线程任务：卖票
	@Override
	public void run(){
		//同步代码块
		while(true){
			synchronized(obj){
			if(ticket>0){  
				try {
                    Thread.sleep((int)Math.random()*10);
                } catch (InterruptedException e) {
                e.printStackTrace();
                }
		       System.out.println(Thread.currentThread().getName()+"正在买第"+ticket+"张票");
			   ticket--;
			   
			}
			}
		}
	}
	
	public static void main(String[] args) {
		//创建Runnable接口的实现类对象
		RunnableImpl r1 = new RunnableImpl();
		//创建Thread对象，构造方法中传递Runnable接口的实现类对象
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r1);
		Thread t3 = new Thread(r1);
		//调用start方法开启多线程
		t1.start();
		t2.start();
		t3.start();
		
	}
}

2.2 使用同步方法

使用synchronized修饰的方法，就叫同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。

格式：

public synchronized void method(){

     可能会产生线程安全问题的代码

}

同步锁是谁？

对于非static方法，同步锁就是this

对于static方法，我们使用当前方法所在类的字节码对象(类名.class)

 使用同步方法实现线程同步的代码：

//模拟卖票案例
class RunnableImpl implements Runnable{
	//定义一个多线程共享的资源
	private int ticket = 30;
	
	
        //设置线程任务：卖票
	@Override
	public void run(){
		while(true){
			method();
		}
	}
	
	public synchronized void method(){
	     if(ticket>0){  
	     try {
                    Thread.sleep((int)Math.random()*10);
                } catch (InterruptedException e) {
                e.printStackTrace();
                }
	        System.out.println(Thread.currentThread().getName()+"正在买第"+ticket+"张票");
		ticket--;
			   
			}
	}
	
	public static void main(String[] args) {
		//创建Runnable接口的实现类对象
		RunnableImpl r1 = new RunnableImpl();
		//创建Thread对象，构造方法中传递Runnable接口的实现类对象
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r1);
		Thread t3 = new Thread(r1);
		//调用start方法开启多线程
		t1.start();
		t2.start();
		t3.start();
		
	}
}

2.3 使用Lock锁

java.util.concurrent.locks.lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/方法具有的功能Lock都有，除此之外更强大，更体现面向对象。

Lock锁也称同步锁，加锁和释放锁方法化了，如下：

public void lock()                加同步锁

public void unlock()            释放同步锁

步骤：

• 在成员位置创建一个ReentrantLock对象
• 在可能出现安全问题的代码前调用Lock接口中的lock()获取锁
• 在可能出现安全问题的代码后调用Lock接口中的unlock()释放锁

使用Lock锁实现进程同步的代码：

package com.goldencis.thread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//模拟卖票案例
public class Thread3 implements Runnable{
    //定义一个多线程共享的资源
    private int ticket = 30;

    Lock l = new ReentrantLock();


    //设置线程任务：卖票
    @Override
    public void run(){
        while(true){
            l.lock();
            if(ticket>0){
                try {
                    Thread.sleep((int)Math.random()*10);
                    System.out.println(Thread.currentThread().getName()+"正在买第"+ticket+"张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                finally{l.unlock();}
            }

        }
    }


    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        Thread3 r1 = new Thread3();
        //创建Thread对象，构造方法中传递Runnable接口的实现类对象
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r1);
        Thread t3 = new Thread(r1);
        //调用start方法开启多线程
        t1.start();
        t2.start();
        t3.start();

    }
}

 

3.同步技术的原理