Java中的线程--线程的互斥与同步通信

　　Java中的线程之前也提到过，但是还是想再详细的学习一下，跟着张孝祥老师，系统的再学习一下。

一、线程中的互斥

线程安全中的问题解释：线程安全问题可以用银行中的转账

例题描述：

线程A与线程B分别访问同一个对象的方法，这样就会存在线程安全的问题，方法的作用是打印出字符串中的每一个字符，方法如下：

 public void output(String name) {
   int len = name.length();
   for (int i = 0; i < len; i++) {
      System.out.print(name.charAt(i));
   }
   System.out.println();
 }

线程A和线程B代码如下：（直接写在了init()方法中了）

     private void init() {
         outputer outputer = new outputer();
         new Thread(new Runnable() {
             @Override
             public void run() {
                 while (true) {
                     try {
                         Thread.sleep(10);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     outputer.output("songshengchao");
                 }
             }
         }).start();
 
         new Thread(new Runnable() {
             @Override
             public void run() {
                 while (true) {
                     try {
                         Thread.sleep(10);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     outputer.output("songxiaochao");
                 }
             }
         }).start();
     }

测试一下，肯定会出现线程不安全的问题，这是母庸质疑的事实，测试代码如下：

     public static void main(String[] args) {
         new TraditionalThreadSynchronized().init();
     }

三种解决办法，代码如下：

 public class outputer {
         public void output(String name) {
             int len = name.length();
             synchronized (this) { // 传进来当前调用方法的对象，要求线程用的是同一个对象
             //synchronized (outputer.class) { // 这样和outputer3方法达到线程互斥
                 for (int i = 0; i < len; i++) {
                     System.out.print(name.charAt(i));
                 }
                 System.out.println();
             }
         }
 
         // 方法上的锁对象用的就是this当前对象
         public synchronized void output2(String name) {
             int len = name.length();
             for (int i = 0; i < len; i++) {
                 System.out.print(name.charAt(i));
             }
             System.out.println();
         }
 
         // output3 想和output方法达到线程互斥
         public static synchronized void output3(String name) {
             int len = name.length();
             for (int i = 0; i < len; i++) {
                 System.out.print(name.charAt(i));
             }
             System.out.println();
         }
     }

注意：至于第三种静态的synchronized方法，在和第一个方法共用时，第一种方法一定是用当前对象的class字节码文件，才能确保两个方法用的同一个对象。

二、线程互斥与通信的经典面试题

面试题：子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，接着在主线程循环100次，如此循环50次，程序如何写？？？

经验之谈，设计思想，设计思路：

要用到共同数据（包括同步锁）的若干个方法应该归在同一个类上，这种设计正好提现了程序的高内聚与健壮性

思路：先写主线程与子线程的循环，然后在考虑轮流执行。先考虑循环，代码如下：

 public class TraditionalThreadCommunication {
 
     public static void main(String[] args) {
 
         new Thread(new Runnable() {
 
             @Override
             public void run() {
                 for (int i = 1; i <= 50; i++) {
                     synchronized (TraditionalThreadCommunication.class) {
                         for (int j = 1; j <= 10; j++) {
                             System.out.println("sub thread sequece of" + j + ", loop of " + i);
                         }
                     }
 
                 }
             }
         }).start();
 
         // 本身main方法就是主线程，直接可以写循环代码
         for (int i = 1; i <= 50; i++) {
             synchronized (TraditionalThreadCommunication.class) {
                 for (int j = 1; j <= 100; j++) {
                     System.out.println("main thread sequece of" + j + ", loop of " + i);
                 }
             }
         }
 
     }
 }

代码优化，用面向对象的思想，将那些代码放到一个公共的类中，然后执行类中的不同方法，优化成一个公共的类，代码如下：

 public class Business {
 
     public synchronized void sub(int i){
         for (int j = 1; j <= 10; j++) {
             System.out.println("sub thread sequece of" + j + ", loop of " + i);
         }
     }
 
     public synchronized void main(int i){
         for (int j = 1; j <= 100; j++) {
             System.out.println("main thread sequece of" + j + ", loop of " + i);
         }
     }
 }
 
 ----------------------------------------------------------------------------------------------
 
 public class TraditionalThreadCommunication {
 
     public static void main(String[] args) {
         Business business = new Business();
         new Thread(new Runnable() {
 
             @Override
             public void run() {
                 for (int i = 1; i <= 50; i++) {
                     business.sub(i);
                 }
             }
         }).start();
 
         // 本身main方法就是主线程，直接可以写循环代码
         for (int i = 1; i <= 50; i++) {
             business.main(i);
         }
 
     }
 
 }

最终的完整代码如下（详细注释）：

 public class Business {
 
     // 是否是子线程执行 默认子线程先执行
     private boolean bShouldSub = true;
 
     public synchronized void sub(int i) {
         // 不是子线程应该执行 让给主线程 子线程执行等待的方法
         while (!bShouldSub) {
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         for (int j = 1; j <= 10; j++) {
             System.out.println("sub thread sequece of" + j + ", loop of " + i);
         }
         // 子线程执行完毕后 让给主线程执行
         bShouldSub = false;
         // 唤醒主线程
         this.notify();
     }
 
     public synchronized void main(int i) {
         // 是子线程应该执行 让给子线程执行 主线程执行等待的方法
         while (bShouldSub) {
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         for (int j = 1; j <= 100; j++) {
             System.out.println("main thread sequece of" + j + ", loop of " + i);
         }
         // 主线程执行费完毕后 交给子线程执行
         bShouldSub = true;
         // 唤醒子线程
         this.notify();
     }
 }
 ------------------------------------------------------------------------------------------------
 
 public class TraditionalThreadCommunication {
 
     public static void main(String[] args) {
         Business business = new Business();
         new Thread(new Runnable() {
 
             @Override
             public void run() {
                 for (int i = 1; i <= 50; i++) {
                     business.sub(i);
                 }
             }
         }).start();
 
         // 本身main方法就是主线程，直接可以写循环代码
         for (int i = 1; i <= 50; i++) {
             business.main(i);
         }
 
     }
 
 }