Java - 线程

Java的线程

了解线程需要先了解进程与线程的关系。
进程：一个可运行的完整的程序代码,是由cpu分配运行资源直到从发展到消亡的过程。
一个进程中存在多个同时运行的线程。
线程：可运行的一段代码,是由5个状态进行的,多个线程组成一个进程。

实现线程的方式

1、继承Thread类
2、实现Runnable接口

线程的状态变化

操作系统层的线程具有5种状态: 创建、就绪、运行、阻塞、终止。

1、创建：在程序用构造方法创建一个线程对象后,线程类就处于新建状态,就已经拥有内存空间和其他资源,但还处于不可运行状态。

2、就绪：就是让线程进入cpu的队列内进行等待,这样就具备可运行的条件,即调用start()。

3、运行：就是cpu分配好资源,自动调用run,执行线程的操作与功能。

4、阻塞：这是一个特殊情况下的状态,如果线程被人为挂起或输出输入超时,线程会被暂停,
如 sleep(),wait(),suspend()等都会进入阻塞,且阻塞的线程不能进入队列,只有阻塞被消除后,
才能进行进入就绪(cpu队列)。

5、终止：线程调用stop()或者run()方法运行完成,程序不再具备可以运行的能力。

java线程有6种状态。
分别为创建、运行中(将操作系统的就绪和运行)统一称为运行中、阻塞、等待(无线等待,需要中断操作)、计时等待(超时自动返回)、终止。

线程的操作

一、join()

线程的让步,其他线程要先等待该线程运行完成后,才可以继续运行。

public static void method01(){
        JoinThread j1 = new JoinThread();
        Thread t1 = new Thread(j1,"线程A");
        t1.start();
        for (int i = 0; i < 5; i++) {

            if (i > 2){
                try {
                    t1.join();//强制让t1线程先运行完成后,其他线程才能继续运行。
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("主线程运行,1 = " + i);
        }
    }

/* join */
class JoinThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "运行,i = " + i);
        }
    }
}

结果输出

二、sleep()

线程的休眠,让线程进入到阻塞状态,让出cpu资源,重新回到队列。

for (int i = 0; i < 50; i++) {
            try {
                //休眠2秒
                sleep(2000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }

三、interrupt()

线程的中断。interrupt() 方法只会中断线程的阻塞状态，并抛出中断异常，不会直接打断正在运行中的线程。如要中断正在 sleep() 状态的子线程 t1 ，在正在运行的另一条线程中调用 t1.interrupt() 即可中断 t1 。

public static void method03(){
      
        InterruptThread i1 = new InterruptThread();
        Thread t1 = new Thread(i1,"线程Q");
        t1.start();
        try {
            Thread.sleep(5000);
        }catch (Exception e){
            e.printStackTrace();
        }

        t1.interrupt();//中止t1线程运行
    }    

/*
* interrupt
* */
class InterruptThread implements Runnable{

    @Override
    public void run() {
        try {
            System.out.println("进入到run运行");
            for (int i = 0; i < 50; i++) {
                if (i == 20) {
                    Thread.sleep(10000);
                    System.out.println("线程休眠结束");
                }
                System.out.println(Thread.currentThread().getName() + "运行,i = " + i);
            }
            System.out.println("线程运行完成");
        }catch (Exception e){
            System.out.println("线程被中断");
        }
    }
}

结果输出

关于interrupt()详细使用可参考这位博主

setDaemon()

后台线程,当java线程结束后,让线程在后台完成运行

       t1.setDaemon(true);//线程在后台运行
       t1.start();

priority()

线程的优先级 1 - 10,数字越高,优先级越高,默认优先级为5。
优先级高会大概率先执行，但只是执行频率更高，不是一定比优先级低的先执行

        t1.setPriority(1);
        t2.setPriority(5);
        t3.setPriority(10);
        t1.start();
        t2.start();
        t3.start();

yield()

线程的礼让,先让其他线程运行。
使用yield()方法会使当前线程从运行状态变成就绪状态。
cpu的程序会在就绪线程中随机选取一条线程，所以礼让是概率事件，不一定会成功。

public static void method06(){
        YieldThread y1 = new YieldThread();
        new Thread(y1,"线程A").start();
        new Thread(y1,"线程B").start();
        new Thread(y1,"线程C").start();
    }

/* yield */
class YieldThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(500);
            }catch (Exception e){
                e.printStackTrace();
            }
            String name = Thread.currentThread().getName();
            System.out.println(name + "运行,i = " + i);
            if (i >= 5 && name.equals("线程A")){
                System.out.println(name + ":我礼让我快乐");
                Thread.currentThread().yield();
            }
        }
    }
}

输出结果

结果输出中线程A的礼让过程分别是不成功和成功。

wait()

作用是让当前线程进入等待状态,同时也会让当前线程释放它所持有的锁。

notify()

当前的线程已经放弃对资源的占有,通知等待的线程来获得对资源的占有权，但是只有一个线程能够从wait状态中恢复

线程的锁机制

线程的同步锁

线程的同步锁:synchronize

             synchronize(同步对象){
                //需要同步的代码
             }
             synchronize void method(){
             //需要同步的代码
             }

线程的死锁

死锁产生的原因通常是多个线程同时访问共享数据时造成冲突。

产生死锁的四个必要条件:

1、互斥条件:
一个资源每次只能被一个进程(线程)使用。

2、占有和等待条件:
已经分配给某个资源的线程可以请求新的资源。

3、不可抢占条件:
已经分配给一个进程的资源不能强行地被抢占,它只能占有它的进程显示的释放。

4、循环等待条件:
系统中一定有两个或者两个以上的进程组成一条环路,该环路中的每一个进程都在等待着下一个进程所占有的资源。

 public static void main(String[] args) {
        DeadLockThread d1 = new DeadLockThread();
        DeadLockThread d2 = new DeadLockThread();
        d1.flat = true;
        d2.flat = false;

        new Thread(d1).start();
        new Thread(d2).start();
    }

class Person1{
    public void say(){
        System.out.println("P1对P2说,你放手,我就放手");
    }
    public void result(){
        System.out.println("P2松开了手");
    }
}

class Person2{
    public void say(){
        System.out.println("P2对P1说,你放手,我就放手");
    }
    public void result(){
        System.out.println("P1松开了手");
    }
}

class DeadLockThread implements Runnable{

    private static Person1 p1 = new Person1();
    private static Person2 p2 = new Person2();
    public boolean flat = false;

    @Override
    public void run() {
        //死锁实现流程
        if (flat) {
            synchronized (p1) {//1、p1执行,p1{}内容被锁
                p1.say();
                try {
                    Thread.sleep(500);// 2、因为进入睡眠,2线程执行
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (p2){//4、因为p2被锁,所以无法执行
                    p1.result();
                }
            }
        }else{
            synchronized (p2) {//3、p2执行,p2{}内容被锁
                p2.say();
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (p1){//5、因为p1被锁,无法执行
                    p2.result();
                }
            }
        }
    }
}

需要注意的是:

静态对象的数据是全局共享的，同个类的每个静态对象都会共享同一数据，而普通对象的数据都是独立的。

锁静态对象时所有实例运行到该处都会被锁住（类级别的锁），而锁实例对象的时候，该锁只对每个实例有效（实例级别的锁) 。

所以如果该锁静态对象的时候，锁了实例对象，会造成该锁无效；如果在该锁实例对象的时候，锁了静态对象，会造成很大的性能问题。