JAVA多线程由浅入深(3)-----线程安全

1.什么是线程安全?

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样

的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

2.以卖票为例实现

public  class Demo03 implements Runnable{
	int ticket=100;
	//以抢票为例,3个机器卖票
	public static void main(String[] args){
		Demo03 demo03=new Demo03();
		Thread t1=new Thread(demo03,"机器1");
		Thread t2=new Thread(demo03,"机器2");
		Thread t3=new Thread(demo03,"机器3");
		
		t1.start();
		t2.start();
		t3.start();
	}
	public void run(){
		while(true){
			if(ticket>0){//有票可以购买
				try{
					Thread.sleep(100);//模拟出票时间
				}catch(InterruptedException e){
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"正在卖"+ticket--);
			}
		}
	}

			
}

3.运行结果,发现卖了-1的票

4.问题分析

(1)线程安全的问题是由全局变量及静态变量引起的,若每个线程中对全局变量或静态变量只有读操作,而不进行写操作,一般情况下这个全局变量的线程是安全的,如有多个线程同时执行写操作,一般需要考虑线程同步,否则的话可能影响线程安全.

5.如何解决

采用同步机制:包括,同步代码块,同步方法,锁机制

(1)同步代码块

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

格式:

synchronized(同步锁){ 
需要同步操作的代码 
}

同步锁:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

1. 锁对象 可以是任意类型。

2. 多个线程对象 要使用同一把锁。

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着

(BLOCKED)。

使用同步代码块解决代码：

public  class Demo03 implements Runnable{
	int ticket=100;
	Object lock = new Object();
	//以抢票为例,3个机器卖票
	public static void main(String[] args){
		Demo03 demo03=new Demo03();
		Thread t1=new Thread(demo03,"机器1");
		Thread t2=new Thread(demo03,"机器2");
		Thread t3=new Thread(demo03,"机器3");
		
		t1.start();
		t2.start();
		t3.start();
	}
	public void run(){
		while(true){
			synchronized(lock){
			if(ticket>0){//有票可以购买
				try{
					Thread.sleep(100);//模拟出票时间
				}catch(InterruptedException e){
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"正在卖"+ticket--);
			}
		}
		}
	}

			
}

结果很安全.

(2)同步方法

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

等着。

public synchronized void method(){ 
可能会产生线程安全问题的代码
 }

同步锁是谁?

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

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

实现代码

public  class Demo03 implements Runnable{
	int ticket=100;
	Object lock = new Object();
	//以抢票为例,3个机器卖票
	public static void main(String[] args){
		Demo03 demo03=new Demo03();
		Thread t1=new Thread(demo03,"机器1");
		Thread t2=new Thread(demo03,"机器2");
		Thread t3=new Thread(demo03,"机器3");
		
		t1.start();
		t2.start();
		t3.start();
	}
	public void run(){
		while(true)
		sellTicket();
	}
	public synchronized void sellTicket(){
			if(ticket>0){//有票可以购买
				try{
					Thread.sleep(100);//模拟出票时间
				}catch(InterruptedException e){
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"正在卖"+ticket--);
			}
	}			
}

(3)Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,

同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也是同步锁,加锁和释放锁的方法

public void lock()   ;加同步锁

public void unlock  ;   释放同步锁

实现代码

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public  class Demo03 implements Runnable{
	int ticket=100;
	Lock lock = new ReentrantLock();
	//以抢票为例,3个机器卖票
	public static void main(String[] args){
		Demo03 demo03=new Demo03();
		Thread t1=new Thread(demo03,"机器1");
		Thread t2=new Thread(demo03,"机器2");
		Thread t3=new Thread(demo03,"机器3");
		
		t1.start();
		t2.start();
		t3.start();
	}
	public void run(){
		while(true){
			lock.lock();//加锁
			if(ticket>0){//有票可以购买
				try{
					Thread.sleep(100);//模拟出票时间
				}catch(InterruptedException e){
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"正在卖"+ticket--);
			}
			lock.unlock();//释放锁;
		}
	}			
}

不用测试了,肯定能够跑出来的哦