线程安全与死锁

一、实现多线程的方式：
方式一：继承Thread类
            a.自定义类继承Thread类
            b.在自定义类中重写run()方法
            c.创建自定义类的对象
            d.启动线程的对象
方式二：实现Runnable接口（大多数使用）
            a.自定义类实现Runnable接口
        b.在自定义类中重写run()方法
            c.创建自定义类的对象
            d.创建Thread类的对象，并把c步骤创建的对象作为构造参数传递
            优点：避免由于单继承带来的局限性
                    适合多个程序的代码处理同一个资源的情况，把线程同程序的代码、数据有效分离，较好的体现了面向对象的设计思想。

public class SellTicket implements Runnable {
private int tickets = 100;
public void run() {
while(true) {
if(tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e） {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票")；
  }
}    
}
}

public class SellTicketDemo {
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st,"窗口1");
Thread t2 = new Thread(st,"窗口2");
Thread t3 = new Thread(st,"窗口3");
t1.start();
t2.start();
t3.start();
}
}

出现多线程安全问题的原因：
        1.是否是多线程环境
        2.是否共享数据
        3.是否有多条语句操作共享数据
二、解决线程安全问题——
方式一、同步代码块
        同步机制：把多条语句操作共享数据的代码给包成一个整体，让某个线程在执行的时候，别人不能来执行
格式：synchronized(对象) {需要同步的代码；}
          同步可以解决安全问题的根本原因就在这个对象上。该对象如同锁的功能。多个线程，需要共同拥有一个对象
          用法：
                  在run()方法外创建一个对象 Object obj = new Object(); 对象是任意创建的
                  .......
while(true) {
                               synchronized(obj) { //相当于一把锁，t1抢到CPU执行权后就锁上了
                                    if(tickets > 0) {
                ....... //t1睡眠时t2，t3也会抢CPU执行权，但由于锁上进不去。当t1执行完后 t1，t2，t3还会再次抢CPU执行权
      同步的特点：多个线程使用的是同一个锁对象
      同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
      同步方法的格式以及锁对象问题
            直接将synchronized加到方法上
            private synchronized void 方法名() {...}
            run()方法中直接调用但是需要注意锁对象的问题
      同步方法的锁对象是this
    静态方法的锁对象是类的字节码文件对象即当前类名.class （静态方法是随着类的加载而加载）
      方式二、Lock锁的使用（Lock属于接口）
            1.明确看到在哪加锁，在哪释放锁
            2.方法：void lock();获取锁 void unlock();释放锁
            3.ReentrantLock是Lock的实现类。
            用法：
                    在自定义类中定义锁对象如：private Lock lock = new ReentrantLock();
                .......
while(true) {
                            try { //加入try是为了防止里面的走错，这样可以直接释放
                                    lock.lock();
if...
                            }finally {
                                lock.unlock();
}...
三、死锁

死锁是指多个线程运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。

产生死锁的四个必要条

互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
环路等待条件：在发生死锁时，必然存在一个进程--资源的环形链。

编写产生死锁的代码

public class TestDeadLock {
    private static Object obj1 = new Object();
    private static Object obj2 = new Object();

    public static void main(String[] args) {
        new Thread(new Thread1()).start();
        new Thread(new Thread2()).start();
    }

    private static class Thread1 implements Runnable {
        @Override
        public void run() {
            synchronized (obj1) {
                System.out.println("Thread1 拿到了 obj1 的锁！");
                try {
                // 停顿2秒的意义在于，让Thread2线程拿到obj2的锁
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj2) {
                    System.out.println("Thread1 拿到了 obj2 的锁！");
                }
            }
        }
    }

    private static class Thread2 implements Runnable {
        @Override
        public void run() {
            synchronized (obj2) {
                System.out.println("Thread2 拿到了 obj2 的锁！");
                try {
                // 停顿2秒的意义在于，让Thread1线程拿到obj1的锁
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj1) {
                    System.out.println("Thread2 拿到了 obj1 的锁！");
                }
            }
        }
    }

}