2、传统的线程互斥synchronized

synchronized使用之基本原则：

synchronized可以锁方法，也可以锁代码片段，但要实现互斥的基本就是在想要互斥的代码上加”同一把锁“，也就是同一个对象，也就是用==判断等于true的对象

下面看一个例子：

Work.java    真正做事情的类

 package com.yzl;

 public class Work {
     /**
      * 未同步的
      * @param name
      */
     public void noSynwrite(String name){
         for(int i=0; i<name.length(); i++){
             System.out.print(name.charAt(i));
             if(i == (name.length()-1)){
                 System.out.print("\n");
             }
         }
     }

     /**
      * 使用同步块，并使用Work的实例对象做为锁
      * 此方法的同步需保证是调用该方法的work对象是同一个
      * @param name
      */
     public void write1(String name){
         synchronized (this) {
             for(int i=0; i<name.length(); i++){
                 System.out.print(name.charAt(i));
                 if(i == (name.length()-1)){
                     System.out.print("\n");
                 }
             }
         }
     }

     /**
      * 使用同步块，并使用Work的字节码做为锁
      * @param name
      */
     public void write1WithStatic(String name){
         synchronized (Work.class) {
             for(int i=0; i<name.length(); i++){
                 System.out.print(name.charAt(i));
                 if(i == (name.length()-1)){
                     System.out.print("\n");
                 }
             }
         }
     }

     /**
      * 使用同步的方法，锁对象为ork的实例对象
      * 此方法的同步需保证是调用该方法的work对象是同一个
      * @param name
      */
     public synchronized void write2(String name){
         for(int i=0; i<name.length(); i++){
             System.out.print(name.charAt(i));
             if(i == (name.length()-1)){
                 System.out.print("\n");
             }
         }
     }

     /**
      * 静态方法的同步方法，同步的对象是对象的字节码，也就是Work.class
      * 如果要与上面的方法一起使用并保持互斥，则可以把write1的锁对象this改成Work.class
      * @param name
      */
     public synchronized static void write3(String name){
         for(int i=0; i<name.length(); i++){
             System.out.print(name.charAt(i));
             if(i == (name.length()-1)){
                 System.out.print("\n");
             }
         }
     }
 }

测试类ThreadPart_2.java

 package com.yzl;

 /**
  * 传统的线程互斥
  * 原理：使用同一个对象（锁）才能实现，
  *         静态方法的同步则只能使用类的字节码也就是ClassName.class来做锁
  * @author yzl
  *
  */
 public class ThreadPart_2 {
     public static void main(String[] args) {
         noSyn();
         synWithOneObj();
         synWithOneStaticObj();
     }

     /**
      * 未线程同步的
      */
     private static void noSyn(){
         final Work work = new Work();

         Thread thread = new Thread(new Runnable() {
             @Override
             public void run() {
                 while(true){
                     work.noSynwrite("wangwu");
                 }
             }
         });
         thread.start();

         Thread thread1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 while(true){
                     work.noSynwrite("zhangsan");
                 }
             }
         });
         thread1.start();
     }

     /**
      * 使用同一个实例对象做为锁的
      */
     private static void synWithOneObj(){
         final Work work = new Work();

         Thread thread = new Thread(new Runnable() {
             @Override
             public void run() {
                 while(true){
                     work.write1("wangwu");
                 }
             }
         });
         thread.start();

         Thread thread1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 while(true){
                     work.write2("zhangsan");
                 }
             }
         });
         thread1.start();
     }

     /**
      * 使用同一个类的字节码做为锁的
      */
     private static void synWithOneStaticObj(){
         Thread thread = new Thread(new Runnable() {
             @Override
             public void run() {
                 while(true){
                     new Work().noSynwrite("wangwu");
                 }
             }
         });
         thread.start();

         Thread thread1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 while(true){
                     Work.write3("zhangsan");
                 }
             }
         });
         thread1.start();
     }
 }

将上面ThreadPart_2的第12、13、14行代码分别依次执行，

第12行代码将出现如下类似结果：

//运行结果部分示例
zhangsan
zhwu
wangwu
wangangsan
zhangsawangwu

第13和14行将是正常的打印各自的名字