黑马程序员：Java基础——多线程之安全问题与同步

------- Java EE培训、java培训、期待与您交流！ ----------

1.安全问题

综合上一篇笔记代码来看，当我们这样写时：

if(tick>0){
	try {
		Thread.sleep(10);   //无法抛出异常
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	System.out.println(Thread.currentThread().getName()+":sale:"+tick--);

会出现如下的错误：

通过分析，发现打印出0，-1，-2等错票，是多线程的运行出现了安全问题。

首先我们来分析下原因：

    当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。

2.同步代码块

那么有问题就得解决：

    对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

    Java对于多线程的安全问题提供了专业的解决方式，就是同步代码块。也就是synchronized模块。

synchronized(对象){
      需要被同步的代码
}

完整代码如下：

<span style="font-size:14px;">class Ticket1 implements Runnable{
	private int tick=100;
	Object obj = new Object();
	public void run(){
		while(true){
			synchronized (obj) {
				if(tick>0){
					try {
						Thread.sleep(10);   //无法抛出异常
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+":sale:"+tick--);
				}
			}
		}
	}
}

public class ThreadSafty {
	public static void main(String[] args) {
		Ticket1 t = new Ticket1();

		Thread d1 = new Thread(t);// 创建一个进程
		Thread d2 = new Thread(t);// 创建一个进程
		Thread d3 = new Thread(t);// 创建一个进程
		Thread d4 = new Thread(t);// 创建一个进程

		d1.start();
		d2.start();
		d3.start();
		d4.start();
	}
}</span>

这次执行的效果就没有了异常票：

这种解决办法类似于单例设计模式。synchronized即锁共享。对象如同锁，持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取到CPU的执行权也无法进入，因为没有获取到锁。

一个比较形象的例子：同一节车厢中火车卫生间的使用

同步的前提：
 1.必须要有两个或者两个以上的线程
 2.必须是多个线程使用同一个锁。
 
 必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题

弊端：多个线程都需要判断锁，较为消耗资源

3.同步函数

先说一个例子：

/**
 * 需求：
 * 银行有一个金库。
 * 有两个储户分别存￥300，每次存￥100，存3次。
 * 
 * 目的：改程序是否有安全问题，如果有，如何解决？
 * 分析：如何找到问题？
 * 1.明确那些代码是多线程运行代码
 * 2.明确共享数据
 * 3.明确多线程运行代码中哪些语句是操作共享数据的
 * 
 * */

class Bank{
	private int sum;
    public void add(int n){
    	sum += n;
    	System.out.println("Sum="+sum);
    }
}

class Cus implements Runnable{
	private Bank b = new Bank();
	public void run(){
		for(int i=0;i<3;i++){
			b.add(100);
		}
	}
}

public class BankThreadDemo {
    public static void main(String[] args) {
	Cus c = new Cus();
	Thread t1 = new Thread(c);
	Thread t2 = new Thread(c);
	
	t1.start();
	t2.start();
	}
}

执行效果如下：

Sum=200
Sum=100
Sum=300
Sum=400
Sum=600
Sum=500

然而当我们这样改的时候：

public void add(int n){
    	sum += n;
    	try {
		Thread.sleep(10);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
    System.out.println("Sum="+sum);
}

执行结果却如下：

Sum=200
Sum=200
Sum=400
Sum=400
Sum=600
Sum=600

也就是出现了错误输出。

那么我们的解决方法是：

public void add(int n){
    Synchronized(obj){
        sum += n;
        try {
    	    Thread.sleep(10);
        } catch (InterruptedException e) {
	    e.printStackTrace();
        }
        System.out.println("Sum="+sum);
    }
}

当然我们也可以在Cus中的run方法里添加synchronized同步锁也就是把b.add(100);放进同步锁中。而我们使用更简洁的方法，也就是将synchronized关键字放在函数修饰中，即

public synchronized void add(int n){
    sum += n;
    try {
	Thread.sleep(10);
    } catch (InterruptedException e) {
	e.printStackTrace();
    }
        System.out.println("Sum="+sum);
}

运行效果与前面的相同。

同步函数的锁是this

先来看这段代码：

我们让线程d1执行同步代码块，让线程d2执行同步函数

<span style="font-size:14px;">/**
 * 同步函数用的是哪一个同步锁？
 * 函数需要被对象调用，那么函数都有一个所属对象引用，就是this。所以同步函数使用的锁是this。
 * 
 * 通过该程序进行验证。
 * 
 * 使用两个线程来买票。
 * 一个线程在同步代码块中
 * 另一个线程在同步函数中
 * 都在执行买票动作。
 * */
class Ticket2 implements Runnable {
	private int tick = 100;
    Object obj = new Object();
    boolean flag = true;
	public void run() {
		if(flag){
			while(true){
				synchronized (obj) {
					if (tick > 0) {
						try {
							Thread.sleep(10); 
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName() + ":--code--:" + tick--);
				    }
				}
			}
		}else{
			while (true) {
		        this.show();
			}
		}
	}
		
	public synchronized void show(){
		if (tick > 0) {
			try {
				Thread.sleep(10); // 无法抛出异常
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ":show:" + tick--);
	    }
	}
}

public class TicketSyncDemo {
	public static void main(String[] args) {
		Ticket2 t = new Ticket2();
		
		Thread d1 = new Thread(t);//创建一个进程
		Thread d2 = new Thread(t);//创建一个进程
		/*Thread d3 = new Thread(t);//创建一个进程
		Thread d4 = new Thread(t);*///创建一个进程
		
		d1.start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t.flag = false;
		d2.start();
		/*d3.start();
		d4.start();*/
	}
}</span>

运行结果如下：

可以看到，两个线程交替运行，但是最后输出的是一个错误的票，0。也就是说这段代码依然不安全。

那么我们将同步代码块中synchronized后的obj改成this:

synchronized (this) {
	if (tick > 0) {
		try {
			Thread.sleep(10); 
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + ":--code--:" + tick--);
    }
}

运行结果如下：

这次代码安全了，而且，两个线程也会交替运行。

静态同步函数的锁是Class对象

/**
 * 若果同步函数被静态修饰后，使用的锁是什么？
 * 通过验证，发现不再是this。因为静态方法中也不可以定义this
 * 
 * 静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
 * 类名.class 该对象的类型是Class
 * 
 * 静态的同步方法，使用的锁是该方法所在类的字节码文件对象，也就是类名.class
 * */

class Ticket3 implements Runnable {
	private static int tick = 100;
    //Object obj = new Object();
    boolean flag = true;
	public void run() {
		if(flag){
			while(true){
				synchronized (Ticket3.class) {
					if (tick > 0) {
						try {
							Thread.sleep(10); 
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName() + ":--code--:" + tick--);
				    }
				}
			}
		}else{
			while (true) {
		        this.show();
			}
		}
	}
		
	public static synchronized void show(){
		if (tick > 0) {
			try {
				Thread.sleep(10); // 无法抛出异常
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ":show:" + tick--);
	    }
	}
}

public class TicketStatDemo {
	public static void main(String[] args) {
		Ticket3 t = new Ticket3();
		
		Thread t1 = new Thread(t);//创建一个进程
		Thread t2 = new Thread(t);//创建一个进程
		
		t1.start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t.flag = false;
		t2.start();
	}
}

运行结果如下：