多线程11_张孝祥 java5的线程锁技术

本例子因为两个线程公用同线程中，使用同一个对象，实现了他们公用一把锁，实现了同一个方法的互斥。

 

package locks;

/**
 *会被打乱的效果
 */
public class LockTest2 {

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

    private void init() {
        //两个线程同时使用同一个Outputer对象，来确保他们使用的是同一把锁
        final 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("zhangxiaoxiang");
                }

            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //在启动一个线程 调用方法   打印  如下代码
                    outputer.output("lileilei");
                }

            }
        }).start();
    }
    // 两个线程调用方法的过程中，不能彼此干扰

    class Outputer {
        
        public void output(String name) {
            
            try {
                int len = name.length();
                for (int i = 0; i < len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

//红色区域是发生打乱的效果
//iaoxiang
//zhangxiaoxiang
//lileilei
//zhangxiaoxialnig
//leilei
//lzihangxiaoxianlg
//eilei
//lilezhaniglxeii
//aoxiang
//zhangxiaoxianglileilei
//
//zhangxiaoxiang
//lileilei
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//zhlileilei
//angxiaoxiang
//lileilei
//zhangxiaoxiang
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiangli
//leilei
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//zhangxiaoxiang
//lileilei
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang
//zhangxiaoxiang
//lileilei
//lileizhangxiaoxiang
//lei
//zhangxiaoxiang
//lileilei
//zhangxiaoxiang

 

 

package locks;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 *不会被打乱的效果
 */
public class LockTest {

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

    private void init() {
        //两个线程同时使用同一个Outputer对象，来确保他们使用的是同一把锁
        final 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("zhangxiaoxiang");
                }

            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //在启动一个线程 调用方法   打印  如下代码
                    outputer.output("lileilei");
                }

            }
        }).start();
    }
    
    class Outputer {
        
        Lock lock=new ReentrantLock();
        //通过锁，可以确保同一时间只有一个线程可以调用此方法
        public void output(String name) {
            
            // 当A线程进入此方法的时候， 如果B也进来，发现A占用次锁， B需要等待该锁被释放才能继续往下执行，
            lock.lock();//加一把所
            System.out.print(Thread.currentThread().getName()+"  ");
            try {
                int len = name.length();
                for (int i = 0; i < len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                
                lock.unlock();//解锁
            }
        }
    }
}
//不被打乱的效果
//lileilei
//zhangxiaoxiang
//zhangxiaoxiang
//lileilei
//lileilei
//zhangxiaoxiang
//zhangxiaoxiang
//lileilei
//lileilei
//zhangxiaoxiang
//lileilei