Java学习笔记之--------线程（三）线程的同步

线程同步

线程同步是多个线程同时访问同一资源，等待资源访问结束。由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。

我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是synchronized关键字。它包括两种方法，synchronized方法和synchronized块。

public class SynDemo01 {
	
	public static void main(String[] args) {
		
		Web12306 web12306 = new Web12306();
		
		Thread t1 = new Thread(web12306, "张三");
		Thread t2 = new Thread(web12306, "李四");
		Thread t3 = new Thread(web12306, "王五");
		//启动线程
	    t1.start();
		t2.start();
		t3.start();
	}
}


class Web12306 implements Runnable {
    // 假定有10张票
    private int num = 10;
    private boolean flag = true;

    @Override
    public void run() {
    	while (flag) {
			test01();
		}
    }
    
    //线程不安全，锁定范围不正确
    public void test06(){
    	if(num<=0){
  			flag=false; //跳出循环
  			return ;
  		}
		synchronized ((Integer)num) {
  		try {
  			Thread.sleep(500); //模拟 延时
  		} catch (InterruptedException e) {
  			e.printStackTrace();
  		}
  		System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
		}
  	}
    
    //线程不安全，锁定资源不正确，此处只锁定了num
    public void test05(){
    	synchronized ((Integer)num) {
    		if(num<=0){
      			flag=false; //跳出循环
      			return ;
      		}
      		try {
      			Thread.sleep(500); //模拟 延时
      		} catch (InterruptedException e) {
      			e.printStackTrace();
      		}
      		System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
		}
  	}
    
    //线程安全，锁定范围不正确
    public void test04(){
    	synchronized (this) {
    		if(num<=0){
      			flag=false; //跳出循环
      			return ;
      		}
		}
    	try {
  			Thread.sleep(500); //模拟 延时
  		} catch (InterruptedException e) {
  			e.printStackTrace();
  		}
  		System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
  	}
    
    //线程安全，锁定正确
    public void test03(){
    	synchronized (this) {
    		if(num<=0){
      			flag=false; //跳出循环
      			return ;
      		}
      		try {
      			Thread.sleep(500); //模拟 延时
      		} catch (InterruptedException e) {
      			e.printStackTrace();
      		}
      		System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
		}
  	}
    
    //线程安全，锁定正确
    public synchronized void test02(){
  		if(num<=0){
  			flag=false; //跳出循环
  			return ;
  		}
  		try {
  			Thread.sleep(500); //模拟 延时
  		} catch (InterruptedException e) {
  			e.printStackTrace();
  		}
  		System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
  	}
    
    //线程不安全
    public void test01(){
  		if(num<=0){
  			flag=false; //跳出循环
  			return ;
  		}
  		try {
  			Thread.sleep(500);
  		} catch (InterruptedException e) {
  			e.printStackTrace();
  		}
  		System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
  	}
}

test01()的执行结果如下图：

由运行结果我们可以看出，test01()是线程不安全的，会出现不同用户得到相同资源的结果。我们使用synchronized方法，test02()的运行结果如下图：

我们可以看出，test02()是线程安全的，不同的用户会分得不同的资源。我那还可以使用synchronized块来实现线程安全，test03()的运行结果如下图：

我们可以看出，test03()是线程安全的。但是使用synchronized块的时候要注意synchronized块的锁定范围，test04()，test05()，test06()因为锁定范围不正确，导致没有实现线程安全。