Java基础-线程操作共享数据的安全问题

　　　　　　　　　　　　　　　　　　　　Java基础-线程操作共享数据的安全问题

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.引发线程安全问题

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

1>.售票案例

　　假设某人一次性买了20张关于周杰伦的演唱会，原计划是请全部门去看演唱会的，但是由于老板的临时任务来袭，被迫需要把这20张票放在交给三个人转卖出去，请你模拟这个买票的过程。我们可以用代码来实现一下：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note;

 class Tickets implements Runnable{
     //定义出售的票源
     private int ticket = 20;
     @Override
     public void run() {
         while(true) {
             //对于票数大于0才可以出售
             if( ticket > 0 ) {
                 try {
                     Thread.sleep(10);
                     System.out.printf(Thread.currentThread().getName()+"出售第[%d]张票\n",ticket--);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }
     }
 }

 public class ThreadDemo {
     public static void main(String[] args) {
         //创建Runnable接口实现了对象
         Tickets t = new Tickets();
         //创建三个Thread类对象，传递Runnable接口实现类
         Thread t1 = new Thread(t,"窗口1");
         Thread t2 = new Thread(t,"窗口2");
         Thread t3 = new Thread(t,"窗口3");
         t1.start();
         t2.start();
         t3.start();

     }
 }
 

　　运行我们写的程序之后，发现了两个问题，即（重复买票还有出现负数票的情况），如下：

2>.分享出现线程安全问题的原因

3>.同步代码块解决线程安全问题

　　我们解决上面案例的思路就是：当一个线程进入数据操作的时候，无论是否休眠，其它线程只能等待。这就需要引入Java的一个关键字，同步锁的概念：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note;

 class Tickets implements Runnable{
     //定义出售的票源
     private int ticket = 20;

     private Object obj = new Object();
     @Override
     public void run() {
         while(true) {
             //线程共享数据，保证安全，可以把一段代码变成一个原子性操作，也就是说当某个线程在执行该操作时，其它的线程进不来！
             synchronized (obj) {
                 //对于票数大于0才可以出售
                 if( ticket > 0 ) {
                     try {
                         Thread.sleep(20);
                         System.out.printf(Thread.currentThread().getName()+"出售第[%d]张票\n",ticket--);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
         }
     }
 }

 public class ThreadDemo {
     public static void main(String[] args) {
         //创建Runnable接口实现了对象
         Tickets t = new Tickets();
         //创建三个Thread类对象，传递Runnable接口实现类
         Thread t1 = new Thread(t,"窗口1");
         Thread t2 = new Thread(t,"窗口2");
         Thread t3 = new Thread(t,"窗口3");
         t1.start();
         t2.start();
         t3.start();

     }
 }

　　执行结果如下：

4>.同步代码块的执行原理

二.同步方法

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.note;

 class Tickets implements Runnable{
     //定义出售的票源
     private int ticket = 20;
     @Override
     public void run() {
         while(true) {
             payTicket();
         }
     }
     //同步方法需要在方法上面用关键字synchronized声明,同步方法中也有对象锁，该锁就是本类对象引用(this).
     //如果同步方法有静态修饰，那么成员变量也需要用静态修饰，静态同步方法中的锁对象是:“类名.class”，即"Tickets.class"。
     public synchronized void payTicket() {
             //对于票数大于0才可以出售
             if( ticket > 0 ) {
                 try {
                     Thread.sleep(20);
                     System.out.printf(Thread.currentThread().getName()+"出售第[%d]张票\n",ticket--);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
     }
 }

 public class ThreadDemo {
     public static void main(String[] args) {
         //创建Runnable接口实现了对象
         Tickets t = new Tickets();
         //创建三个Thread类对象，传递Runnable接口实现类
         Thread t1 = new Thread(t,"窗口1");
         Thread t2 = new Thread(t,"窗口2");
         Thread t3 = new Thread(t,"窗口3");
         t1.start();
         t2.start();
         t3.start();
     }
 }

　　代码执行结果如下：

三.Lock接口改进售票案例

　　我们用synchronized关键字实现同步锁方法，我们也知道非静态默认所就是本类对象引用(this).如果同步方法有静态修饰，那么成员变量也需要用静态修饰，静态同步方法中的锁对象是:“类名.class”。但是我们很难实现在程序看出来它是在哪上锁，又是在哪解锁。这个时候我们Java开发者在JDK1.5版本后退出了Lock接口，该接口就可以清晰的表示程序应该在哪个位置上上锁，又是在哪个位置上解锁。我们用实现Lock接口的子类ReentrantLock来进行模拟，代码如下：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.note;

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

 class Tickets implements Runnable{
     //定义出售的票源
     private int ticket = 20;
     //在类的成员位置创建lock获取锁
     private Lock lock = new ReentrantLock();

     @Override
     public void run() {
         while(true) {
             payTicket();
         }
     }
     //用lock锁也可以进行锁操作，可以和synchronzied实现同样的效果，并且可以清晰的在程序中看出在哪个位置上锁和解锁。
     public  void payTicket() {
             //调用Lock接口方法获取锁
             lock.lock();
             //对于票数大于0才可以出售
             if( ticket > 0 ) {
                 try {
                     Thread.sleep(50);
                     System.out.printf(Thread.currentThread().getName()+"出售第[%d]张票\n",ticket--);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }finally {
                     //释放锁，调用Lock接口方法unlock
                     lock.unlock();
                 }
             }
     }
 }

 public class ThreadDemo {
     public static void main(String[] args) {
         //创建Runnable接口实现了对象
         Tickets t = new Tickets();
         //创建三个Thread类对象，传递Runnable接口实现类
         Thread t1 = new Thread(t,"窗口1");
         Thread t2 = new Thread(t,"窗口2");
         Thread t3 = new Thread(t,"窗口3");
         t1.start();
         t2.start();
         t3.start();
     }
 }

四.线程的死锁问题

　　线程的死锁前提是：必须是多线程出现同步嵌套。多线程场景下，多个线程互相等待对方释放锁的现象。

　　在实际生活中，死锁就好比两个小孩子打架，两个人彼此扯住对方的头发，谁也不撒手，都等着对方先松手为止。再比如我们看电影，尤其是成龙的动作片，经常出现两个搭档，电影中两个搭档去执行任务，一个人拿到了 抢，成龙达到了子弹，然后两个人分别跑到了走廊的两侧，发现彼此都达到了对方想要的东西，他们无法完成开枪的操作。在代码里，就变现为同步的嵌套，即拿着一个锁的同时，想要获取另外一个锁，此时另外一个锁拿走了当前线程需要锁并且等待着当前锁释放锁，即两个线程彼此等待对方释放锁的情况。我们可以用代码来模仿一下

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note;

 class MyLock{
     //构造方法私有化
     private MyLock() {}
     //由于构造方法私有化，让用户只能通过"类名.静态方法"的方式调用(此处我们不考虑反射的情况！)
     public final static MyLock lockA = new MyLock();
     public final static MyLock lockB = new MyLock();

 }

 class Deadlock implements Runnable{
     private int i = 0;
     @Override
     public void run() {
         while(true) {
             if( i % 2 == 0 ) {
                 //先进去A同步，在进入B同步
                 synchronized(MyLock.lockA) {
                     System.out.printf("【%s】已经拿到了枪，准备去拿子弹！\n",Thread.currentThread().getName());
                     synchronized(MyLock.lockB) {
                         System.out.printf("【%s】成功拿到子弹！\n",Thread.currentThread().getName());
                     }
                 }
             }else {
                 //先进入B同步，在进入A同步
                 synchronized(MyLock.lockB) {
                     System.out.printf("【%s】已经拿到子弹，准备去拿枪！\n",Thread.currentThread().getName());
                     synchronized(MyLock.lockA) {
                         System.out.printf("【%s】成功拿到枪！\n",Thread.currentThread().getName());
                     }
                 }
             }
             i++;
         }
     }
 }

 public class DeadLockDemo {
     public static void main(String[] args) {

         Deadlock dead = new Deadlock();

         Thread t1 = new Thread(dead,"成龙");
         Thread t2 = new Thread(dead,"李连杰");

         t1.start();
         t2.start();
     }
 }

　　以上代码执行结果如下：

五.线程等待案例展示

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note1;

 public class Resource {
     public String name;
     public String sex;
     //定义一个标志位，让其默认值为false
     public boolean flag = false;
 }

Resource.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note1;

 //定义一个输入的线程，对资源对象Resource中成员变量赋值
 public class Input implements Runnable {
     //让用户在调用时手动传入，若传入的对象是同一个，那么多个线程就可以实现对同一个线程进行操作
     private Resource r ;
     public Input(Resource r) {
         this.r = r;
     }

     public void run() {
         while(true) {
             int i = 0;
             while(true) {
                 synchronized (r) {
                     //表示是true时，表示赋值完成，我们可以让线程进入休眠状态
                     if(r.flag) {
                         try {
                             //让检查进入等待状态，也就是不会执行其下面的代码！
                             r.wait();
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                     }
                     //如果标志位的值为false，则说明Resource对象并没有赋值，我们需要做的是赋值操作！
                     if(i % 2 == 0) {
                         r.name = "尹正杰";
                         r.sex = "男";
                     }else {
                         r.name = "yinzhengjie";
                         r.sex = "man";
                     }
                     //以上操作完成了赋值，标记改为true！
                     r.flag = true;
                     //此时将Output线程唤醒，让对方知道赋值已经完成，可以来取值啦！
                     r.notify();
                 }
                 i++;
             }
         }
     }

 }

Input.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note1;

 //定义输出线程，对资源对象Resource中成员变量，输出值。
 public class Output implements Runnable {
     //让用户在调用时手动传入，若传入的对象是同一个，那么多个线程就可以实现对同一个线程进行操作
     private Resource r ;
     public Output(Resource r) {
         this.r = r;
     }

     public void run() {
         while(true) {
             //注意，在选择锁的时候，若锁不相同，可能存在和我们期望的结果有偏差！
             synchronized (r) {
                 //判断标志位的值是否为false，如果是则说明其是等待状态，我们需要的就是去取值！
                 if(!r.flag) {
                     try {
                         r.wait();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
                 System.out.println(r.name+"==="+r.sex);
                 //标记改为false，
                 r.flag = false;
                 //表示赋值完成，唤醒Input线程。
                 r.notify();
             }
         }
     }

 }

Output.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note1;

 public class ThreadDemo {
     public static void main(String[] args) {
         Resource r = new Resource();

         Input in = new Input(r);
         Output out = new Output(r);

         Thread t1 = new Thread(in);
         Thread t2 = new Thread(out);

         t1.start();
         t2.start();
     }
 }