黑马程序员：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=200Sum=100Sum=300Sum=400Sum=600Sum=500

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

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

执行结果却如下：

Sum=200Sum=200Sum=400Sum=400Sum=600Sum=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();}}

运行结果如下：