死锁,同步锁

死锁:不同线程,分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了死锁

同步锁:使用Lock

比较Lock与synchronized:

1. 相同点:都解决了线程安全问题
2. 不同点:synchronized需要制定同步监视器,且保证同步监视器的唯一性,且不管是同步代码块还是同步方法,在出了对应的大括号后,就会自动的释放同步监视器
3. lock的实例需要保证是唯一的
4. lock必须显式的调用unlock()方法,才会释放对共享数据的占用
5. 总结:Lock的方式 ,优于同步代码块,优于同步方法

package threadtest;

import java.util.concurrent.locks.ReentrantLock;

public class Ruanble {
    
    public static void main(String[] args) {
        //创建实现类的对象
        Num num=new Num();
        //将此对象作为参数传递给Thread类的构造器,创建Thread类的对象
        Thread thread1 =new Thread(num);
        Thread thread2 =new Thread(num);
        Thread thread3 =new Thread(num);
        //调用start()启动创建的Thread对象
        
        thread1.setName("线程一");
        thread2.setName("线程二");
        thread3.setName("线程三");
        
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
//创建一个类实现Runable接口
class Num implements Runnable{
    int ticket=100;
    //定义同步监视器,多个线程共同使用唯一的同步监视器
    //lock的实例化
    private ReentrantLock lock =new ReentrantLock();
    /*Object obj=new Object();*/
    //重写run方法
    @Override
    public void run() {
      while (true) {
        try {
            //上锁
            lock.lock();
            if (ticket>0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()  +"开始售票,票号为"+   ticket);
                ticket--;
            }else {
            break;
        }
     }finally {
         //解锁
        lock.unlock();
    }
    }
    
}
}