2022-07-19 线程

一、线程相关概念

（一）、进程

1.进程是指运行中的程序，比如使用qq，就启动了一个进程，操作系统就会为该进程分配内存空间，当我们使用迅雷，又启动了另一个进程
2.进程是程序的一次执行过程，或是正在运行的一个程序，是动态过程：有它自身的产生、存在和消亡的过程

（二）、线程

1.线程由进程创建，是进程的一个实体
2.一个进程可以有多个线程
3.单线程：同一时刻，只允许执行一个线程
4.多线程：同一时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件

（三）、并行和并发

1.并行：同一时刻，多个任务同时执行，多个cpu可以实现并行
2.并发：同一时刻，多个任务交替执行，造成一种"貌似同时"的错觉，简单地说，单核cpu实现的多任务就是并发

二、线程的基本使用

（一）、创建线程的两种方式

1.继承Thread类，重写run方法
2.实现Runnable接口，重写run方法

（二）、继承Thread和实现Runnable的区别

1.没有本质区别，Thread也是实现了Runnable接口
2.实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制

（三）、线程终止

1.当线程完成任务后，会自动退出
2.还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
3.注意：主方法线程结束，进程不一定结束，可能里面还有其他线程在执行

（四）、线程常用方法

1.setName：设置线程名称，使之与参数name相同
2.getName：返回线程名称
3.start：线程开始执行、Java底层调用该线程的start0方法
4.run：调用线程对象的run方法
5.setPriority：更改线程优先级
6.getPriority：获取线程优先级
7.sleep：线程休眠
8.interrupt：中断线程
9.yield：线程礼让，让出cpu，让其他线程先执行，但是礼让时间不确定，所以也不一定礼让成功
10.join：线程插队，先执行完插队的线程的所有任务

package com.szhstd.threadMethod_;

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        Hello hello = new Hello();
        hello.start();
        for (int i = 0; i < 20; i++) {
            Thread.sleep(1000);
            System.out.println("hi" + i);
            if (i == 4) {
                hello.join();
            }
        }
    }
}

class Hello extends Thread {
    @Override
    public void run() {
        int count = 0;
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("hello" + (++count));
            if (count == 20) {
                break;
            }
        }
    }
}

(五)、注意事项和细节

1.start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程
2.线程优先级的范围
3.interrupt，中断线程，但没有真正的结束线程，所以一般用于中断正在休眠的线程
4.sleep：线程的静态方法，使当前线程休眠

（六）、用户线程和守护线程

1.用户线程：也叫工作线程，当线程的任务执行完成或通知方式结束
2.守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
3.常见的守护线程：垃圾回收机制

（七）、线程的生命周期

1.New：尚未启动的线程
2.Runnable：在Java虚拟机中执行的线程处于此状态
3.Blocked：被阻塞等待监视器锁定的线程处于此状态
4.Waiting：等待另一个线程
5.Time_Waiting：超时等待
6.Terminated：已退出的线程

三、Synchronized

（一）、线程同步机制

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

（二）、同步方法

1.同步代码块
Synchronized（对象）{ //得到对象的锁，才能操作同步代码
//需要被同步的代码；
}
2.Synchronized还可以放在方法声明中，表示整个方法为同步方法
public Synchronized void m（String name）{
//需要被同步的代码
}

package com.szhstd.syn;

public class SellTickets {
    public static void main(String[] args) {
        Tickets tickets = new Tickets();
        new Thread(tickets).start();
        new Thread(tickets).start();
        new Thread(tickets).start();
    }
}


class Tickets implements Runnable {
    private boolean loop = true;
    private static int tickets = 100;

    public synchronized void sell() {//同步方法，使得最多只有一个线程进入方法
        if (tickets <= 0) {
            System.out.println("票已卖完...");
            loop = false;
            return;
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + (--tickets));
    }

    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            sell();
        }
    }
}

3.我遇到的问题：当synchronized里面休眠时，可能会只有一条线程进行，其他线程不执行
4.解决办法：当sleep在synchronized同步方法或同步块之外的时候,三个线程都有执行, 是因为sleep方法会给其他线程运行的机会,而不管其他线程的优先级, (但在synchronized同步方法里的sleep, 由于被锁住所以没有优先级之说, 也就是说synchronized同步方法里的sleep失效了)

四、互斥锁

（一）、基本介绍

1.保证共享数据操作的完整性
2.每个对象都对应一个可称为“互斥锁”的标记，这个标记用来保证在任意时刻，只能有一个线程访问该对象
3.同步的局限性：导致程序的执行效率降低
4.同步方法（非静态的）的锁可以是this，也可以是其他对象（要求是同一个对象）
5.同步方法（静态的）的锁为当前类本身

五、线程的死锁

1.多个线程都占用了对方的资源，但不肯相让，导致了死锁

六、释放锁

（一）、下面操作释放锁

1.当前线程的同步方法、同步代码块执行结束
2.当前线程在同步方法、同步代码块中遇到break、return
3.当前线程的同步方法、同步代码块中出现了未处理的Error或Exception，导致异常结束
4.当前线程的同步方法、同步代码块中执行了线程对象的wait（）方法，当前线程暂停，并释放锁

（二）、下面操作不会释放锁

1.线程执行同步方法、同步代码块时，程序调用Thread.sleep（）、Thread.yield（）方法暂停当前线程的执行，不会释放锁
2.线程执行同步方法、同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，不会释放锁