Java多线程安全和死锁

线程生命周期

➢新建:当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
➢就绪:处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它己具备了运行的条件，只是没分配到CPU资源
➢运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态，run()方法定义了线程的操作和功能
➢阻塞:在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中，止自己的执行，进入阻塞状态
➢死亡:线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

线程安全问题解决

synchronized

方式一：同步代码块

synchronized(){
	//需要被同步的代码
}

说明:
1.操作共享数据的代码，即为需要被同步的代码
2.共享数据:多个线程共同操作的变量。比如: ticket就是共享数据。
3.同步监视器，俗称:锁。任何一个类的对象，都可以充当锁。
要求:多个线程必须要共用同- -把锁。

使用synchronized时，如果使用的是runnable的接口实现方法，那么synchronized()里的形参在私有类中直接声明一个object类即可，但是如果使用的是继承Thread的方法，那么要将其object类变成为静态属性。因为runnable实现的多线程使用的都是new出来的同一个类，而Thread实现的多线程每个线程我们都需要New出来，使用的不是同一个类。

public class test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        MyThread myThread1 = new MyThread();
        myThread1.start();
    }
}


class MyThread extends Thread{
    static int ticket = 100;
    private static Object object = new Object();
    public void run(){
        synchronized (object) {
            while (ticket > 0) {
                System.out.println(ticket);
                ticket--;
            }
        }
    }

public class test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        Thread thread1 = new Thread(myThread);
        thread.start();
        thread1.start();
    }
}


class MyThread implements Runnable{
    int ticket = 100;
    private Object object = new Object();
    public void run(){
        synchronized (object) {
            while (ticket > 0) {
                System.out.println(ticket);
                ticket--;
            }
        }
    }
}

补充:在实现Runnable 接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

public class test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        Thread thread1 = new Thread(myThread);
        thread.start();
        thread1.start();
    }
}


class MyThread implements Runnable{
    int ticket = 100;
    //private Object object = new Object();
    public void run(){
        synchronized (this) {
            while (ticket > 0) {
                System.out.println(ticket);
                ticket--;
            }
        }
    }
}

方式二：同步方法

public class test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        Thread thread1 = new Thread(myThread);
        thread.start();
        thread1.start();
    }
}


class MyThread implements Runnable{
    int ticket = 100;
    //private Object object = new Object();
    public void run(){
        while (ticket > 0) {
            show();
        }
    }
    private synchronized void show(){
        System.out.println(ticket);
        ticket--;
    }
}

public class test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        MyThread myThread1 = new MyThread();
        myThread.start();
        myThread1.start();
    }
}


class MyThread extends Thread{
    static int ticket = 100;
    //private Object object = new Object();
    public void run(){
            while (ticket > 0) {
                show();
            }
    }
    private static synchronized void show(){
        System.out.println(ticket);
        ticket--;
    }
}

关于同步方法的总结:
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2.非静态的同步方法，同步监视器是: this。静态的同步方法，同步监视器是:当前类本身

死锁

死锁演示：

public class test{
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread(){
            public void run(){
                synchronized (s1){
                    try {
                        sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    s1.append("a");
                    System.out.println("111");
                    s2.append("1");
                    System.out.println("222");
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
        new Thread(){
            public void run(){
                synchronized (s2){
                    s1.append("c");
                    s2.append("3");
                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
    }
}

Lock

public class test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        Thread thread1 = new Thread(myThread);
        thread.start();
        thread1.start();
    }
}

class MyThread implements Runnable{
    int ticket = 100;
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (ticket > 0){
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + ':' + ticket);
                ticket--;
            }finally {
                lock.unlock();
            }
        }
    }
}

两者的不同

相同:二者都可以解决线程安全问题
不同: synchronized 机制在执行完相应的同步代码以后，自动的释放同步监视器Lock需要手动的启动同步(Lock())，同时结束同步也需要手动的实现(unLock() )