Java多线程的概念和使用

线程相关概念

程序(program)：是为完成特定任务、用某种语言编写的一组指令的集合。

进程是指运行中的程序，比如使用qq，就启动一个程序，操作系统就会为该进程分配内存空间

。当又使用酷狗，又启动一个进程，操作系统为酷狗分配新的内存空间。

进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程；有它自身的产生、存在、消亡的过程。

线程是由进程创建的，是进程的一个实体。一个进程可以拥有多个线程。

例如下载多个文件，同时在下载。

单线程：同一个时刻，只允许执行一个线程，如酷狗音乐在放歌时，只能放一首

多线程：同一个时刻，可以执行多个线程，比如一个qq进程，可以打开多个聊天界面，

并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，

单核cpu实现多任务就是并发

并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。

实现线程的两种方式

1.继承Thread类，重写run方法

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat对象，可以当作线程使用
        Dog dog = new Dog();
        //cat.run();run就是一个普通方法，没有真正启动一个线程，就会把run方法执行完毕，才会向下执行
        dog.start();//启动线程-》最终会执行cat的run方法
        System.out.println("主线程继续执行"+Thread.currentThread().getName());
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程i"+i);
            Thread.sleep(1000);
        }
    }
}
//当一个类继承了Thread类，该类可以当作线程使用
//重写run方法，写上自己的业务代码
class Dog extends Thread{
    int times = 0;
    @Override
    public void run() {
       while(true){
           System.out.println(Thread.currentThread().getName()+"程序"+(++times)+"正在启动");
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }

           if (times==8){
               break;
           }
       }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ertiytww-1627551204364)(D:\java开发\java笔记\images\多线程.png)]

start()方法调用start0()方法后，该线程不一定会立马执行，只是将线程变成可运行状态。至于什么时候执行，

取决于cpu，由cpu统一调度。

2.实现Runnable接口，重写run方法

Java是单继承的，在某些情况下一个类已经继承了多个某个父类，这时候不可能再用继承Thread类实现方法创建线程。这时候就可以用到通过实现Runnable接口来创建线程

public class Thrad02 {
    public static void main(String[] args) {
       Mouse mouse = new Mouse();
       //在这里不能直接调用start方法，需要创建Thread对象，把mouse对象(实现Runnable)，放入Thread
       Thread thread = new Thread(mouse);
       thread.start();
    }
}
class Mouse implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while (true){
            System.out.println("老鼠吱吱叫"+(++count)+Thread.currentThread().getName());
            //休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (count==8){
                break;
            }
        }

    }
}

public class SellTickle {
    public static void main(String[] args) {
        SellTicket01 sellTicket01 = new SellTicket01();
        new Thread(sellTicket01).start();
        new Thread(sellTicket01).start();
        new Thread(sellTicket01).start();
    }
}
class SellTicket01 implements Runnable{
    //一个网站的用户访问量
    private static int tickNum = 0;
    @Override
    public void run() {
        while(true){
            if (tickNum <= null){
                System.out.println("目前没有用户访问"+(tickNum++));
                break;
            }
            else if (tickNum == 20){
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("用户"+Thread.currentThread().getName()+"访问网站的次数"+(++tickNum));

        }
    }
}

线程终止

1.当线程完成任务后，会自动退出

2.通过使用变量来控制run方法退出的方式停止线程

public class ThreadExit {
    public static void main(String[] args) throws InterruptedException {
        B b = new B();
        b.start();
        //如果希望主线程去控制b线程的终止，必须修改loop
        //让b退出run方法，从而终止了b线程 ——>通知方式
        //让主线程休眠5秒，在通知b线程退出
        System.out.println("主线程休眠5秒");
        Thread.sleep(5*1000);
        b.setLoop(false);
    }
}
class B extends Thread{
    private int count = 0;
    //设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
        while (loop){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("B线程运行中");
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程中断

常用方法

1.setName：设置线程名，使与参数name参数相同
2.getName：获取该线程的名称
3.start：使该方法线程开始执行；Java虚拟机底层调用该线程的start0方法
4.run：调用线程对象run方法
5.setPriority：更改线程的优先级
6.getPriority：获取线程的优先级
7.sleep：指定的毫秒数让正在执行的线程休眠(暂停执行)
8.interrupt：中断线程

注意事项

1.start底层会创建新的线程，调用run，run就是简单的方法调用，不会启动新线程

2.线程优先级的范围

3.interrupt中断线程，但是并没有真正的结束线程。所以一般用于中断正在休眠线程

4.sleep：线程的静态方法，使当前线程休眠。

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        a.setName("刘先生");
        //确定线程的优先级
        a.setPriority(Thread.MIN_PRIORITY);
        //线程运行
        a.start();
        System.out.println(a.getName());
        //中断子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("刘先生吃完了又要准备开吃了");
        }
        System.out.println(a.getName()+"线程的优先级"+a.getPriority());
        a.interrupt();//执行到这里，就会中断a线程的休眠
    }
}
class A extends Thread{
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "吃包子" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + "吃完东西需要消化");
                Thread.sleep(2 * 10000);
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
                System.out.println(Thread.currentThread().getName() + "被interrupt");
            }
        }
    }
}

线程插队

线程插队方法

1.yield：线程的谦虚礼让。让出cpu，让其他的线程运行，但在这里时间不确定，所以不一定成功
2.join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

用户线程和守护线程

1.用户线程：也叫工作线程，当线程的任务执行完或通知方式结束

2.守护线程：通常都是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

​ 一个形象的比喻就是人的影子，我们做什么他们就会做什么

3.常见的守护线程：垃圾回收机制

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果希望主线程结束后，子线程自动结束
        //只需将子线程设为守护线程即可
        //注意守护线程的创建要放在运行线程的前面
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();
        for (int i = 1; i <=10 ; i++) {
            System.out.println("妻子为老公在默默付出");
            Thread.sleep(1000);
        }
    }
}
class MyDaemonThread extends Thread{
    public void run() {
        for (;;) {//等价于while（true）的无限循环
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("老公正在上班");
        }
    }
}

线程七大状态

线程状态：线程处于以下状态之一：

New：尚未启动的线程处于此状态

Runnable：在Java虚拟机中执行的线程处于此状态

Blocked：被阻塞等待监视器锁定的线程处于此状态

Waiting:正在等待另一个线程执行特定动作的线程处于此状态

Timed_Waiting:正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

Terminated：已退出线程处于此状态

Runnable：可分为两个状态：Ready状态：就绪状态和Running：运行状态

线程同步机制

1.在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术

，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性

2.还可以这样理解：线程同步，即当有一个线程在内存进行操作，其他线程都不可以对这个内存地址

进行操作，直到线程完成操作，其他线程才能对该内存地址进行操作。

同步具体方法

1.同步代码块

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

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

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

线程常用方法

	start：启动线程
	run：将线程要执行的操作放在这里面
	currentThread：获取当前执行代码对应的线程
	getName：获取线程名
	setName：设置线程名
	sleep：将当前线程睡眠设置指定的毫秒数
	yield：静态方法，一旦执行方法，就会释放cpu的执行权
	join：在线程a中通过线程b调用join，这就意味着a进入了阻塞状态，只能等到线程b执行结束，线程a才能继续执行
	isAlive：判断线程是否存活

线程生命周期机制图

互斥锁

基本介绍

1.Java语言中，引入对象互斥锁的概念，来保证共享数据操作的完整性

2.每个对象都对应了名为互斥锁的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象

3.关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任何时刻

只能由一个线程访问

4.同步的局限性：导致程序的执行效率变低

5.同步方法（非静态）的锁可以是this，也可以是其他对象（要求是同一个对象）

6.同步方法（静态）的锁为当前类本身

相关细节问题

1.同步方法如果没使用static修饰：默认锁对象为this

2.如果方法使用static修饰，默认锁对象：当前类.class

3.实现的落地步骤：
需要分析上锁的代码

​ 选择同步代码块或同步方法

​ 要求多个线程的锁对象为同一个即可

线程死锁

基本介绍

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

例如生活中：

爸爸：你先完成作业，再打篮球

自己：先打完篮球，在完成作业

//模拟一个死锁的现象
public class DeadLockDemo {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLock deadLock01 = new DeadLock(true);
        deadLock01.setName("First");
        deadLock01.start();
        DeadLock deadLock02 = new DeadLock(false);
        deadLock02.setName("Second");
        deadLock02.start();
    }
}
class DeadLock extends Thread{
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;

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

    @Override
    public void run() {
        //1.如果为真会先得到持有o1对象锁
        //2.如果为假会先得到持有o2对象锁
        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()+"进入3");
                synchronized (o1){
                    System.out.println(Thread.currentThread().getName()+"进入4");
                }
            }
        }
    }
}

释放锁

常见的释放锁的操作

1.当前线程的同步方法、同步代码块执行结束；就好比要办一件事，最后弄完了

2.当前线程在同步代码块，同步方法遇到break，return；你办完一件事，结果后回来发现还有错误重新解决问题

3.当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束

​ 这就类似你上课没带笔，不得已去买笔

4.当前线程在同步代码块，同步方法中执行了线程对象的wait()方法，当前线程暂停

​ 并释放锁。你干活累了需要休息会再去干

不会释放锁的操作

1.线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yieldf方法暂停

​ 当前线程的执行，不会释放锁。解释：太困了，上课学习睡着了

2.线程执行同步代码块时，其他线程调用该线程的suspend()方法将该线程挂起，该线程不会释放锁
​ 注意：尽量避免使用suspend()和resume()来控制线程