Lock同步_小记

使用同步机制的这种方式解决线程安全问题,但是不知道具体的锁对象在哪里添加,并且锁对象在哪里释放锁对象,对于这种情况Jdk5以后Java提供了一个更具体的锁对象:Lock
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作
*
Lock是一个接口,所以它在使用的是 ReentrantLock子实现类
*
* public void lock()获取锁。
* public void unlock()试图释放此锁

对象类package Day21_Lock;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * @author Aoman_Hao */public class UseLock implements Runnable{    private int tickets=20;    public int x=0;    //定义一个具体的锁对象    private Lock lock = new ReentrantLock();    @Override    public void run() {        while(true){            try {                lock.lock();                if(tickets>0){                        Thread.sleep(100);                          System.out.println(Thread.currentThread().getName()+"窗口出售第"+(tickets--)+"张票");                }else{                    break;                }            } catch (Exception e) {            }            finally{                //释放锁对象                lock.unlock();            }               }    }}测试类：package Day21_Lock;/** * @author Aoman_Hao */public class LockTest {    public static void main(String[] args) {        UseLock UL = new UseLock();        Thread t1 = new Thread(UL, "窗口1");        Thread t2 = new Thread(UL, "窗口2");        Thread t3 = new Thread(UL, "窗口3");        t1.start();        t2.start();        t3.start();    }}输出：窗口1窗口出售第20张票窗口1窗口出售第19张票窗口1窗口出售第18张票窗口1窗口出售第17张票窗口1窗口出售第16张票窗口2窗口出售第15张票窗口2窗口出售第14张票窗口2窗口出售第13张票窗口3窗口出售第12张票窗口3窗口出售第11张票窗口3窗口出售第10张票窗口3窗口出售第9张票窗口3窗口出售第8张票窗口3窗口出售第7张票窗口3窗口出售第6张票窗口3窗口出售第5张票窗口3窗口出售第4张票窗口3窗口出售第3张票窗口3窗口出售第2张票窗口3窗口出售第1张票

---

使用同步机制可以解决多线程的安全问题,但是自身也会有弊端:
* 1)同步—->执行效率低(每一个线程在抢占到CPU的执行权,会去将(门)关闭,别的线程进不来)
* 2)容易出现死锁现象
*
* 死锁线程:两个或者两个以上的线程出现了互相等待的情况,就会出现死锁!
*

classa：public class DeadClassA {    public void FirstClassA(){        try {            Thread.sleep(100);        } catch (Exception e) {            System.out.println("进程名："+Thread.currentThread().getName()+"调用A的First方法内部");        }    }    public void LastClassA(){        System.out.println("A的Last方法内部");    }}classb：public class DeadClassB {    public void FirstClassB(){        try {            Thread.sleep(100);        } catch (Exception e) {            System.out.println("进程名："+Thread.currentThread().getName()+"调用B的first方法");        }    }    public void LastClassB(){        System.out.println("进入B的Last方法内部");    }}对象类：public class DeadLock implements Runnable {    Object obj = new Object();    Object obj2 = new Object();    private boolean flag;//定义一个判断量    public void lockflag(boolean flag){        this.flag=flag;    }    @Override    public void run() {        if(flag){            //先调用A类的第一个方法，在调用B类的最后一个方法            synchronized (obj) {                new DeadClassA().FirstClassA();                try {                    Thread.sleep(100);                } catch (InterruptedException e) {                    e.printStackTrace();                }                synchronized (obj2) {                    new DeadClassB().LastClassB();                }            }        }        else{            //先调用B类的第一个方法，在调用A类的最后一个方法            synchronized (obj2) {                try {                    Thread.sleep(100);                } catch (InterruptedException e) {                    e.printStackTrace();                }                new DeadClassB().FirstClassB();                synchronized (obj) {                    new DeadClassA().LastClassA();                }            }    }    }   }测试类：public class DeadLockTest {    public static void main(String[] args) {        DeadLock DL = new DeadLock();        DL.lockflag(true);        Thread T1 = new Thread(DL);        DeadLock DL2 = new DeadLock();        DL2.lockflag(false);        Thread T2 = new Thread(DL);        T1.start();        T2.start();    }}