线程之线程的互斥

public class TraditionalSynchronized {

    
    public static void main(String[] args) {
        
        TraditionalSynchronized a = new TraditionalSynchronized();
        final Outputer outputer = a.new Outputer();
        
        new Thread(new Runnable(){

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

            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("abcdefg");
                }
            }
            
        }).start();
    }
    
//    class Outputer{
//        public void output(String string){
//            int length = string.length();
//            for(int i=0;i<length;i++){
//                System.out.print(string.charAt(i));
//            }
//            System.out.println();
//        }
//    }
    //有两个字符串对象访问 outputer，会出现随机的交叉线出现，这不是希望得到的  ,下例提供解决办法，改写Outputer
    
    
//    class Outputer{
//        public void output(String string){
//            int length = string.length();
//            synchronized (string) {
////在这里是起不到作用的，synchronized (string)中的这个括号里面的 对象必须要是同一个，这两个字符串显然不是
//                for(int i=0;i<length;i++){
//                    System.out.print(string.charAt(i));
//                }
//                System.out.println();
//            }
//            
//        }
//    }
    
    //再次改写class Outputer,方式一
    //这种方式能保证了synchronized (xxx)的xxx是同一个对象，但是似乎不是那么的优雅
    //如果把outputer.output("abcdefg");改写 new Outputer().output("abcdefg");这种改写就不能应付了，因为这种事xxx也不是同一个对象了
    
//    class Outputer{
//        String xxx = "";
//    public void output(String string){
//        int length = string.length();
//        synchronized (xxx) {
//            for(int i=0;i<length;i++){
//                System.out.print(string.charAt(i));
//                }
//            System.out.println();
//            }
//        
//        }
//    }
    
    //下面的改写办法 this
    
//    class Outputer{
//        public void output(String string){
//            int length = string.length();
////这个this在某些时候也能写Output.class,特别是在出现静态方法是互斥的时候只能写作字节码的形式
//            synchronized (this) {
//                for(int i=0;i<length;i++){
//                    System.out.print(string.charAt(i));
//                }
//                System.out.println();
//        }
//    
//    }
//}
    
    //还有种简单的方法，就是给这个方法加上synchronized，这个作用范围就是这个方法了
    
    class  Outputer{
    public synchronized void output(String string){
        int length = string.length();
            for(int i=0;i<length;i++){
                System.out.print(string.charAt(i));
            }
            System.out.println();
        }
    }
    
    //synchronized在一个方法上用一次，否则出现死锁
        
}