Java学习之路（五十二）| 线程（三）—— 线程七大状态、线程同步机制、互斥锁、线程死锁、释放锁

各自努力，最高处见！加油！

一、线程的七大状态

七大状态分别为：初始化状态，就绪状态，运行状态，死亡状态，阻塞状态，超时等待，等待状态。
在网络上看到一位大佬将七大状态归纳得很好，所以在这里放上该帖子的链接：线程的七大状态

代码：实例探索线程在实际执行过程中的状态

public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        C c=new C();
        System.out.println(c.getName()+"状态"+c.getState());//获取当前线程的状态
        c.start();
        while(Thread.State.TERMINATED!=c.getState()){
            //只要进程还没结束，程序就一直在获取当前的状态
            System.out.println(c.getName()+"状态"+c.getState());
            Thread.sleep(1000);
        }
        System.out.println(c.getName()+"状态"+c.getState());

    }
}

class C extends Thread{
    @Override
    public void run() {
        while(true){
            for (int i = 0; i < 10; i++) {
                System.out.println("hi"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

二、线程同步机制（Synchronize）

什么是线程同步：在多线程编程中，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何一个时刻，最多有一个线程访问，以保证数据的完整性。

实现同步的两种方法：

1. 同步代码块

synchronize(对象 ){//得到对象的锁，才能操作同步代码
		//需要被同步的代码；
}

2. synchronize还可以放在方法声明中，表示整个方法为同步方法

public synchronized void m(String name){
		//需要被同步的代码
}

三、互斥锁

1. Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
2. 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只有一个线程访问该对象。
3. 关键字synchronize与对象的互斥锁对应。当某个对象用synchronize修饰时，表明该对象在任一时刻只能由一个线程访问。
4. 同步的局限性：导致程序的执行效率要降低。
5. 同步方法（非静态）的锁可以是this，也可以是其他对象（但是要求多个线程访问的是同一个对象）。默认为this。
6. 同步方法（静态的）锁为当前类本身。默认为当前类.class
7. 优先选择同步代码块：理论上锁的范围越小，代码执行效率越高。

public synchronized static void m1(){}//锁加载当前的类上
public static void m2(){
		synchronized(SellTicket.class){//静态方法中想要在代码块中设置线程安全，要将类名（SellTicket）和后缀（.class）写上
			System.out.println("m2");
		}
}

示例代码：

public class SellTicketSynchronized {
    public static void main(String[] args) {
        SellTicked sellTicket01=new SellTicked();

        //把同个对象放到三个线程，创建三个SellTicket对象的时候并没有满足多线程锁同一个对象的目的，没有达到锁的目的。
        //类比多个人排队上一个厕所的例子。
        Thread thread1 = new Thread(sellTicket01);
        Thread thread2 = new Thread(sellTicket01);
        Thread thread3 = new Thread(sellTicket01);
        thread1.start();
        thread2.start();
        thread3.start();
    }

}
class SellTicked implements Runnable{
    public static int ticketNum=100;
    private  boolean loop=true;
    //sell()就是一个同步方法，锁在this对象上。
    Object object=new Object();

    //也可以在代码块上写synchronize
    public synchronized void sell(){
        synchronized (/*this*/object){//synchronnized修饰代码块，可以将this换成任一对象
            if (ticketNum<=0){
                loop=false;
                return;
            }
            ticketNum--;
            System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"+"剩余票数："+(ticketNum));
        }

        if (ticketNum<=0){
            loop=false;
            return;
        }
        ticketNum--;
        System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"+"剩余票数："+(ticketNum));
    }
        @Override
        public void run() {
            while (loop){

                sell();
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
}

四、线程死锁

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生。

示例代码

public class DeadLock_ {
    public static void main(String[] args) {
        DeadLockDemo A=new DeadLockDemo(true);
        A.setName("A");
        DeadLockDemo B=new DeadLockDemo(false);
        B.setName("B");
        A.start();
        B.start();
    }
}
class DeadLockDemo extends Thread{
    //保证多线程共享一个对象，这里使用static
    static Object o1=new Object();
    static Object o2=new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    /***
     * 如果flag为T，线程 A 就会先持有 o1 的对象锁，然后去尝试获取 o2 的对象锁，如果线程 A 得不到 o2 的对象锁，就会block
     * 如果flag为F，线程 B 就会先持有 o2 的对象锁，然后去尝试获取 o1 的对象锁，如果线程 B 得不到 o1 的对象锁，就会block
     * A和B进程同时需要对方所想的对象锁，却又不能释放，所以程序死锁。
     */
    @Override
    public void run() {
        if (flag){
            synchronized (o1){
                System.out.println(Thread.currentThread().getName()+" 进入1");
                synchronized (o2){
                    System.out.println(Thread.currentThread().getName()+" 进入2");
                }
            }
        }else{
            synchronized (o2){
                System.out.println(Thread.currentThread().getName()+" 进入2");
                synchronized (o1){
                    System.out.println(Thread.currentThread().getName()+" 进入1");
                }
            }
        }
    }
}

运行结果

五、释放锁

下面的操作会释放锁

1. 当前线程的同步方法、同步代码块执行结束。案例：上厕所，完事出来。
2. 当前线程在同步方法、同步代码块中遇到break，return。案例：没有完事，要修改bug，不得已出来。
3. 当前线程在同步方法、同步代码块中出现了未处理的Error或Execption，导致异常结束。
4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

下面的操作不会释放锁

1. 线程执行同步代码块或同步方法时，程序调用了Thread.sleep(),Thread.yield()方法暂停当前程序的执行，不会释放锁。
2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起（进入Ready状态），该线程不会释放锁。注意：应该尽量避免使用suspend()和resume()来控制线程。