java多线程(二)线程的互斥

多线程相对于单线程而言，大大的提高了硬件CPU的使用率，提高了处理的速度。任何事物带来的都是两面性的，多线程为我们带来性能提高的同时也带来了许多的安全性问题。
说互斥之前，先说一下什么是互斥，举个列子，一天去ATM机取钱，如果没有互斥的话，你正取着钱突然有个人冲进来把你的钱抢走了。这时候你想，要是我有个锁我把门给锁住，等我取完了在把锁打开，这样子其他人就没法子冲进来取我的钱了吧，简单说，就是在干一件事的时候，不允许任何人进来打扰我。同样的多线程中也存在类似的问题，解决的办法呢就是加上锁。
看个代码列子
 
Java代码  收藏代码
public static void main(String[] args) {  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                String data = "woshiyigezhongguoren";  
                for(int i=1;i<100;i++){  
                    try {  
                        Thread.sleep(20);  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                    }  
                    for(int j=0;j<data.length();j++){  
                        System.out.print(data.charAt(j));  
                    }  
                    System.out.println();  
                }  
            }  
        }).start();  
          
        String data = "tashilianggren";  
        for(int i=1;i<100;i++){  
            try {  
                Thread.sleep(20);  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
            for(int j=0;j<data.length();j++){  
                System.out.print(data.charAt(j));  
            }  
            System.out.println();  
        }  
    }  
 没有互斥的结果
 
 
Java代码  收藏代码
woshiyigezhongguoren  
tashilianggren  
woshiyigezhongguoren  
tashilianggren  
tashilianggren  
woshiyigezhongguoren  
twoshiyigezhaosnhiglgiuaonrgegn  
ren //这里出问题了   
twashilianggroesn  
hiyigezhongguoren  
tashilianggren  
   这就好比你去取钱取到一半main线程冲进来了，把你的钱抢走了。在jdk1.5之前是解决办法是为这段代码加上一个锁用法非常的简单
Java代码  收藏代码
synchronized(锁对象){  
}  
 使用同一个锁对象做锁的代码块是安全的，你想嘛，我都锁住了，我不放开锁别人别想进来嘛。
Java代码  收藏代码
public static void main(String[] args) {  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                String data = "woshiyigezhongguoren";  
                for(int i=1;i<100;i++){  
                    try {  
                        Thread.sleep(20);  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                    }  
                    synchronized (Test.class) { //同步锁 这里使用的类模板为锁  
                    for(int j=0;j<data.length();j++){  
                        System.out.print(data.charAt(j));  
                    }  
                    System.out.println();  
                    }  
                }  
            }  
        }).start();  
          
        String data = "tashilianggren";  
        for(int i=1;i<100;i++){  
            try {  
                Thread.sleep(20);  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
            synchronized (Test.class) { //同步锁 这里使用的类模板为锁  
            for(int j=0;j<data.length();j++){  
                System.out.print(data.charAt(j));  
            }  
            System.out.println();  
            }  
        }  
    }  
   加上锁之后synchronized中只能有一个线程同时执行，并且在线程的执行过程中不会被干扰，锁都在自己手里，谁还能打扰的了呢。所以上面的问题解决了。
  第二种解决方案，同样也是加锁，jdk1.5提供了新的并发包，改进了锁的性能，而且将隐式锁转变为显示锁，就是说我们可以用代码调用方法来获取锁，释放锁。
Java代码  收藏代码
    final Lock lock = new ReentrantLock();  
    new Thread(new Runnable() {  
        @Override  
        public void run() {  
            String data = "woshiyigezhongguoren";  
            for(int i=1;i<100;i++){  
                try {  
                    Thread.sleep(20);  
                } catch (InterruptedException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                try {  
                    lock.lock(); //获取锁  
                    for(int j=0;j<data.length();j++){  
                        System.out.print(data.charAt(j));  
                    }  
                    System.out.println();  
                }finally{  
                    lock.unlock(); //必须手动的释放锁 放在finally中  
                }  
            }  
        }  
    }).start();  
      
    String data = "tashilianggren";  
    for(int i=1;i<100;i++){  
        try {  
            Thread.sleep(20);  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        try {  
            lock.lock();//获取锁  
            for(int j=0;j<data.length();j++){  
                System.out.print(data.charAt(j));  
            }  
            System.out.println();  
        }finally{  
            lock.unlock();//必须手动的释放锁 放在finally中  
        }  
    }  
}  
   这样也解决我们的问题。jdk1.8又添加了新的锁。据说性能又有提高呢。这篇就到这里吧。