目录

Lock锁

死锁

线程状态

• Lock锁

  • java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
  • Lock锁也称同步锁，加锁与释放锁方法化了
  • 接口实现类：java.util.locks.lock.ReentrantLock
  • public void lock() :加同步锁。
  • public void unlock():释放同步锁。

/**
 *  JDK1.5新特性:
 *    JUC   java.util.concurrent  并发包
 *    java.util.concurrent.locks包中定义接口Lock
 *    目的取代synchronized, 新的锁对象
 *
 *    学习接口: 方法,实现类
 *    lock()获取锁
 *    unlock()释放锁
 *    接口的实现类ReentrantLock,
 */
public class ThreadDemo {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();
    }
}

public class Ticket implements Runnable {
    private int tickets = 100;
    private Lock lock = new ReentrantLock();
    public void run() {
        while (true){
          // synchronized (this) {
            lock.lock();
               if (tickets > 0) {
                   //线程休眠
                   try {
                       Thread.sleep(10);
                   } catch (Exception ex) {
                   }
                   System.out.println(Thread.currentThread().getName() + " 出售第::" + tickets--);
               }
          // }
            lock.unlock();
        }
    }
}

死锁

死锁是指两个或两个以上的线程在执行过程中，由于竞争同步锁而产生的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的线程称为死锁。

根据图中所示：线程T1正在持有R1锁，但是T1线程必须要再获取到R2锁才能继续执行，而线程T2正在持有R2锁，但是T2线程必须再获取到R1锁后才能继续执行，两个线程就会处于无限的等待中，即死锁。在程序中的死锁将出现在同步代码块的嵌套中。

public class LockA {
    private LockA(){}
    public static LockA lockA = new LockA();
}

public class LockB {
    private LockB(){}
    public static LockB lockB = new LockB();
}

public class DeadLock implements Runnable {
    private boolean flag ;
    public DeadLock(boolean flag){
        this.flag = flag;
    }
    public void run(){
        while (true) {
            //判断变量值
            if (flag) {
                //flag=true 先进入A同步,再进入B同步
                synchronized (LockA.lockA) {
                    System.out.println("if...A");
                    synchronized (LockB.lockB) {
                        System.out.println("if...B");
                    }
                }
            } else {
                //flage=false 先进入B同步,再进入A同步
                synchronized (LockB.lockB) {
                    System.out.println("else...B");
                    synchronized (LockA.lockA) {
                        System.out.println("else...A");
                    }
                }
            }
        }
    }
}

/**
 * 启动线程实现死锁
 */
public class ThreadDemo {
    public static void main(String[] args) {
        DeadLock d1 = new DeadLock(true);
        DeadLock d2 = new DeadLock(false);
        Thread t0 = new Thread(d1);
        Thread t1 = new Thread(d2);
        t0.start();
        t1.start();
    }
}

线程状态

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中`java.lang.Thread.State`这个枚举中给出了六种线程状态：