理解java多线程基础部分只需这篇文章

昱晟168

已于 2022-03-08 21:09:35 修改

阅读量348

点赞数 1

分类专栏： java多线程基础文章标签： java 开发语言后端

于 2022-03-02 19:23:47 首次发布

本文链接：https://blog.csdn.net/weixin_47267628/article/details/123237674

版权

java多线程基础专栏收录该内容

2 篇文章 0 订阅

订阅专栏

多线程基础

线程相关概念

程序program

程序是静态，进行是动态

是为完成特定任务，用某种语言编写的一组指令的集合。简单的理解就是我们写的代码

进程

1.进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用另外一个软件，又启动了一个进程，操作系统将另一个软件分配新的内存空间。

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

什么是线程

1.线程由进程创建的，是进程的一个实体

2.一个进程可以拥有多个线程，例如在QQ音乐软件中可以同时下载多首歌曲

其它相关概念

1.单线程：同一个时刻，只允许执行一个线程

2.多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件

3.并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说明：单核cpu实现的多个任务就是并发的

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jm1BexX8-1646219231351)(E:\Typora笔记\java笔记\img\image-20220228211540360.png)]$

4.并行：同一个时刻，多个任务同时执行，多核cpu可以实现并行，并发和并行可以是同时存在的【应用程序个数多于cpu个数】

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3nfs3Riy-1646219231352)(E:\Typora笔记\java笔记\img\image-20220228211606885.png)]$

线程基本使用

创建线程的两种方式：

在java中线程来使用有两种方法

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

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jz0ibL4c-1646219231353)(E:\Typora笔记\java笔记\img\image-20220301160012959.png)]$

继承`Thread`类

线程快速入门的案例：

1.请编写程序，开启一个线程，该线程每隔1秒，
在控制台输出“喵喵，我是一只小猫咪”
2.对上题改进：当输出8次“喵喵，我是一只小猫咪”，结束该线程
3.使用JConsole监控线程执行情况，并画出程序示意图

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vUOFr0a9-1646219231353)(E:\Typora笔记\java笔记\img\image-20220301161503336.png)]$

继承Thread类做成线程类需要五个步骤：

继承Thread类
重写run方法
将业务逻辑写在run方法中
创建类对象
调用start方法【start方法调用了start0方法，start0方法才是真正开启一条线程方法【底层自动调用run方法】】

package thread_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class Thread01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.start();
    }
}

class Cat extends Thread{//第一步：继承 Thread类
    @Override
    public void run() {// 重写run方法 将业务逻辑写在run方法中
        // 每隔1秒，在控制台输出 “喵喵，我是小猫咪”
        // 当输出 8 次，结束该线程
        int times = 0;
        while (true){
            System.out.println("喵喵，我是小猫咪"+(++times));
            if (times == 8)
                break;
        }
    }
}

当我们在编译器run时，java的jvm就会启动一个进程，在进程中启动main线程【也称为主线程】，如果在main线程中又有对象调用start方法时启动一个线程，说明在main线程中又启动了子线程【两者是交替执行的，不会阻塞】

注意是：在java的jvm启动一个进程后，至少启动了两个线程，一个是主线程另一个是垃圾收回线程，一个主线程结束，不能代表进程的结束，要一个进程中的所有线程结束，进程才结束【也就是不能说明主方法结束，进程就结束】

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ctJnSWeq-1646219231354)(E:\Typora笔记\java笔记\img\image-20220301164647695.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dFcWp9bH-1646219231355)(E:\Typora笔记\java笔记\img\image-20220301181057695.png)]$

package thread_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
        cat.start();//会启动一个线程，自动调用start方法
//        cat.run();注意是如果直接调用run方法，那不是启动一个线程，而是直接调用run方法，这是串行的执行
//        【所以说明要调用start方法才能启动一个线程】

        /**
         * 源码剖析：
         * 当我们调用start方法后：
         * public synchronized void start() {
         *      调用一个start0()方法【这个方法才是真正的启动一个线程】
         *          start0();
         *      }
         *
         *      java的jvm会在底层调用start0()方法开启一个线程【start0才是真正开启线程方法】
         *       private native void start0();底层是用C/C++实现的
         */

        for (int i = 0; i < 60; i++) {
            Thread.sleep(1000);
            System.out.println("我是主线程"+Thread.currentThread().getName());
        }
    }
}

class Cat extends Thread{//第一步：继承 Thread类
    @Override
    public void run() {// 重写run方法 将业务逻辑写在run方法中
        // 每隔1秒，在控制台输出 “喵喵，我是小猫咪”
        // 当输出 8 次，结束该线程
        int times = 0;
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("喵喵，我是小猫咪"+(++times));
            if (times == 80)
                break;
        }
    }
}

package com.hspedu.threaduse;

/**
 * 演示通过继承Thread 类创建线程
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {

        //创建Cat对象，可以当做线程使用
        Cat cat = new Cat();

        //老韩读源码
        /*
            (1)
            public synchronized void start() {
                start0();
            }
            (2)
            //start0() 是本地方法，是JVM调用, 底层是c/c++实现
            //真正实现多线程的效果， 是start0(), 而不是 run
            private native void start0();

         */

        cat.start();//启动线程-> 最终会执行cat的run方法



        //cat.run();//run方法就是一个普通的方法, 没有真正的启动一个线程，就会把run方法执行完毕，才向下执行
        //说明: 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
        //这时 主线程和子线程是交替执行..
        System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字main
        for(int i = 0; i < 60; i++) {
            System.out.println("主线程 i=" + i);
            //让主线程休眠
            Thread.sleep(1000);
        }

    }
}

//老韩说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */



class Cat extends Thread {

    int times = 0;
    @Override
    public void run() {//重写run方法，写上自己的业务逻辑

        while (true) {
            //该线程每隔1秒。在控制台输出 “喵喵, 我是小猫咪”
            System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
            //让该线程休眠1秒 ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times == 80) {
                break;//当times 到80, 退出while, 这时线程也就退出..
            }
        }
    }
}

实现`Runnable`接口

说明：

java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能了
java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程

应用案例：

请编写程序，该程序可以每隔1秒，
在控制台输出“小狗汪汪叫”，
当输出10次后，自动退出。
请使用实现``Runnable``接口方式实现。
【这里底层使用了设计模式中的静态代理模式】

package thread_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class Thread02 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Dog());
        thread.start();

        /**
         * 模拟静态代码模式
         */

        Pig pig = new Pig();
        ThreadProxy proxy = new ThreadProxy(pig);
        proxy.start();
    }
}

class Animal {}
class Pig extends Animal implements Runnable {
    @Override
    public void run() {
        int count = 0;
        while (true) {
            System.out.println("猪叫。。。");
            if (count == 10)
            break;
        }
    }
}

class ThreadProxy {
    private Runnable target;

    public ThreadProxy(Runnable target) {
        this.target = target;
    }
    
    public void run(){
        if (target != null){
            target.run();//动态绑定机制
        }
    }
    
    public void start(){
        start0();
    }
    
    public void start0(){//相当于开启一条线程
        run();
    }
}

/**
 * 实现Runnable接口作为线程  五个步骤
 * 1.实现Runnable接口
 * 2.重写run方法
 * 3.将业务逻辑放在run方法中
 * 4.创建该类对象和Thread对象，并将该类对象放在创建Thread中当作参数
 * 5.调用start方法
 */
class Dog implements Runnable {
    @Override
    public void run() {
        int count = 0;
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("小狗汪汪叫。。。"+(++count)+"\t"+Thread.currentThread().getName());
            if (count ==10)
                break;
        }
    }
}

线程基本使用练习题

线程使用应用案例-多线程执行
请编写一个程序，创建两个线程，
一个线程每隔1秒输出“Hello World”，
输出10次退出，一个线程每隔1秒输出“hi”，输出5次退出。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XwPC79jr-1646219231355)(E:\Typora笔记\java笔记\img\image-20220301184302783.png)]$

package thread_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();
    }
}

class T1 implements Runnable {
    @Override
    public void run() {
        int count = 0;
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("hello world "+Thread.currentThread().getName()+"\t"+(++count));
            if (count == 10){
                break;
            }
        }
    }
}

class T2 implements Runnable {
    @Override
    public void run() {
        int count = 0;
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("hi..."+Thread.currentThread().getName()+"\t"+(++count));
            if (count == 5)
                break;
        }
    }
}

线程如何理解

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5tekVUGb-1646219231356)(E:\Typora笔记\java笔记\img\image-20220301190829099.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-75hRAFur-1646219231356)(E:\Typora笔记\java笔记\img\image-20220301190850527.png)]$

线程的理解就是当我们运行一个程序时，java的jvm就启动了一个进程，在进程中调用主线程，主线程可以才开启多个子线程

继承`Thread`和实现`Runnable`的区别

从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质没有区别，从jdk帮助文档中我们可以看到Thread类本身就实现了Runnable接口
实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，一般珈更加建议使用Runnable接口

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QzJ1ZnTa-1646219231356)(E:\Typora笔记\java笔记\img\image-20220301191521721.png)]$

练习

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-58FPBAkP-1646219231357)(E:\Typora笔记\java笔记\img\image-20220301192909299.png)]$

package thread_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class SellTicket {
    public static void main(String[] args) {
//        SellTicket01 ticket01 = new SellTicket01();
//        SellTicket01 ticket02 = new SellTicket01();
//        SellTicket01 ticket03 = new SellTicket01();
//        Thread thread1 = new Thread(ticket01);
//        Thread thread2 = new Thread(ticket02);
//        Thread thread3 = new Thread(ticket03);
//        thread1.start();
//        thread2.start();
//        thread3.start();

        SellTicket02 t1 = new SellTicket02();
        SellTicket02 t2 = new SellTicket02();
        SellTicket02 t3 = new SellTicket02();
        t1.start();
        t2.start();
        t3.start();
    }
}

// 方式一：实现Runnable接口售票
class SellTicket01 implements Runnable{

    private static int ticketNum = 100;
    private static int count;
    //由于启动三个线程售票，所以是共享变量需要作成static的

    @Override
    public void run() {

        while (true) {
            if (ticketNum == 0)
                break;
            System.out.println("该窗口售票一张 ， 还剩下" + (--ticketNum) + "张票\t"+(++count));
        }
    }
}

// 方式二：继承Thread类售票
class SellTicket02 extends Thread {
    private static int ticketNum = 100;
    private static int count;
    @Override
    public void run() {
        while (true) {
            if (ticketNum == 0){
                break;
            }
            System.out.println("该窗口售票一张 , 还剩下"+ (--ticketNum)+"张票\t"+(++count));
        }
    }
}

package com.hspedu.ticket;

/**
 * 使用多线程，模拟三个窗口同时售票100张
 */
public class SellTicket {
    public static void main(String[] args) {

        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里我们会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程


        System.out.println("===使用实现接口方式来售票=====");
        SellTicket02 sellTicket02 = new SellTicket02();

        new Thread(sellTicket02).start();//第1个线程-窗口
        new Thread(sellTicket02).start();//第2个线程-窗口
        new Thread(sellTicket02).start();//第3个线程-窗口


    }
}


//使用Thread方式

class SellTicket01 extends Thread {

    private static int ticketNum = 100;//让多个线程共享 ticketNum

    @Override
    public void run() {
        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));

        }
    }
}



//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum，如果是实现了Runnable接口的可以不修饰成静态的，只创建一个该类对象，直接创建三次Thread类，传入该对象就达到了共享的目的

    @Override
    public void run() {
        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2

        }
    }
}

线程终止

基本说明：

当线程完成任务后，会自动退出
还可以通过使用变量来控制run方法退出的方式停止线程，即通过方式

特别注意是：如果一个线程的run方法退出后，说明该线程已经中止了

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XD3phvDb-1646219231357)(E:\Typora笔记\java笔记\img\image-20220301202233049.png)]$

package thread_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class ThreadExit {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        Thread thread = new Thread(t);
        thread.start();

        // 使主线程休眠 10 秒
        System.out.println("让主线程休眠 10 秒");
        Thread.sleep(10000);
        //　通过修改 T 中的loop变量使 T 中的run方法退出，让该线程中止
        t.setLoop(false);
    }
}

class T implements Runnable {
    // 通过设置loop属性的值，使该类的run方法退出，中止该线程
    private boolean loop = true;
    private int count = 0;

    public void setLoop (boolean loop){
        this.loop = loop;
    }
    @Override
    public void run() {
        while (loop){
            System.out.println(Thread.currentThread().getName()+"\t"+(++count));
        }
    }
}

package com.hspedu.exit_;

public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

        //如果希望main线程去控制t1 线程的终止, 必须可以修改 loop
        //让t1 退出run方法，从而终止 t1线程 -> 通知方式

        //让主线程休眠 10 秒，再通知 t1线程退出
        System.out.println("main线程休眠10s...");
        Thread.sleep(10 * 1000);
        t1.setLoop(false);
    }
}

class T extends Thread {
    private int count = 0;
    //设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {

            try {
                Thread.sleep(50);// 让当前线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中...." + (++count));
        }

    }

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

线程常用方法

1.setName  		// 设置线程名称，使之与参数name相同
2.getName 		// 返回该线程的名称
3.start			// 使该线程开始执行，java虚拟机底层调用该线程start()方法
4.run			// 调用线程对象run方法
5.setPriority	// 更改线程的优先级
6.getPriority	// 获取线程的优先级
7.sleep			// 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
8.interrupt		// 中继线程
9.yield			// 线程的礼让，让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功
10.join			// 线程的插队，插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务
11.daemon       // 守护线程，传入true，表示是守护线程【必须先设置守护，再调用start方法开启线程，否则抛出异常】

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GFH80RXH-1646219231357)(E:\Typora笔记\java笔记\img\image-20220301213157319.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZKsjDGLa-1646219231358)(E:\Typora笔记\java笔记\img\image-20220301213131258.png)]$

注意事项和细节

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

2.线程优先级的范围

3.interrupt中继线程，但并没有真正的结束线程，所以一般用于中断正在休眠线程【意思就是叫醒该线程】

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

package thread_.method_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        // 设置 t 线程的名称
        t.setName("海康");
        t.setPriority(Thread.MAX_PRIORITY);//设置线程的优先级
        t.start();//开启线程
        System.out.println(t.getPriority());// 获取线程优先级

        // 中继t线程【就是叫醒它，起来吃鸡腿了】
        // 先让主线程先输出五次 hi ，再中继t线程【就是叫醒它，起来吃鸡腿了】

        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi "+i);
        }
        t.interrupt();
    }
}

class T 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("休眠20秒再起来吃鸡腿");
                Thread.sleep(20000);//休眠20秒再起来吃鸡腿
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName()+"被interrupt了");
            }
        }
    }
}

package thread_.method_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        myThread t = new myThread();
        t.start();

        // 让主线程礼让CPU
        for (int i = 0; i < 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程说了"+"hi "+i+"次");
            if (i == 5)
                t.join();//表示让 t 线程插队，并执行 t 所有任务完成后，再执行 主线程任务
        }

//        Thread.yield();// 让主线程礼让CPU
    }
}

class myThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程说了"+"hello word "+ i+"次");
        }
    }
}

package com.hspedu.method;

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相关的方法
        T t = new T();
        t.setName("江苏");
        t.setPriority(Thread.MIN_PRIORITY);//1
        t.start();//启动子线程


        //主线程打印5 hi ,然后我就中断 子线程的休眠
        for(int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }

        System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1

        t.interrupt();//当执行到这里，就会中断 t线程的休眠.



    }
}

class T extends Thread { //自定义的线程类
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "  吃包子~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
                Thread.sleep(20000);//20秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt 方法时，就会catch 一个 异常, 可以加入自己的业务代码
                //InterruptedException 是捕获到一个中断异常.
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }
    }
}

package com.hspedu.method;

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {

        T2 t2 = new T2();
        t2.start();

        for(int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程(小弟) 吃了 " + i  + " 包子");
            if(i == 5) {
                System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
                //join, 线程插队
                //t2.join();// 这里相当于让t2 线程先执行完毕
                Thread.yield();//礼让，不一定成功..
                System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
            }

        }
    }
}

class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程(老大) 吃了 " + i +  " 包子");
        }
    }
}

练习题目：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rl3Ob92I-1646219231358)(E:\Typora笔记\java笔记\img\image-20220301215352255.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mb6pVA0U-1646219231359)(E:\Typora笔记\java笔记\img\image-20220301220156653.png)]$

package thread_.method_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        MyT myT = new MyT();

        // 主线程每隔 1 秒，输出 hi ，一共 10 次
        for (int i = 0; i < 10; i++) {
            if (i == 5){
                Thread thread = new Thread(myT);
                thread.start();
                thread.join();
            }
            Thread.sleep(1000);
            System.out.println("hi "+ i);
        }
        System.out.println("主线程结束 。。。");
    }
}

class MyT implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("hello word "+ i);
        }
        System.out.println("子线程结束 ");
    }
}

 package com.hspedu.method;


public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        Thread t3 = new Thread(new T3());//创建子线程
        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            if(i == 5) {//说明主线程输出了5次 hi
                t3.start();//启动子线程 输出 hello...
                t3.join();//立即将t3子线程，插入到main线程，让t3先执行
            }
            Thread.sleep(1000);//输出一次 hi, 让main线程也休眠1s
        }
    }
}

class T3 implements Runnable {
    private int count = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println("hello " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

用户线程和守护线程

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

package thread_.method_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class ThreadDaemonMethod {
    public static void main(String[] args) throws InterruptedException {
        MT mt = new MT();
        mt.setDaemon(true);//需要传入true才能设置成守护线程，
        // 必须先设置守护线程，再开启线程 否则抛出异常
        mt.start();
        
        // 注意是当用户线程结束工作后，守护线程自动退出去【就守护自动中止】

        for (int i = 0; i<20 ;i++){
            Thread.sleep(1000);
            System.out.println("主线程 "+i);
        }

    }
}

class MT extends Thread{
    @Override
    public void run() {
        for(;;){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("坏人在聊天 。。。");
        }
    }
}

package com.hspedu.method;

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我们希望当main线程结束后，子线程自动结束
        //,只需将子线程设为守护线程即可
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();

        for( int i = 1; i <= 10; i++) {//main线程
            System.out.println("宝强在辛苦的工作...");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread {
    public void run() {
        for (; ; ) {//无限循环
            try {
                Thread.sleep(1000);//休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("马蓉和宋喆快乐聊天，哈哈哈~~~");
        }
    }
}

线程的生命周期

在jdk中用Thread.State枚举表示了线程的几种状态

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3npIZCel-1646219231359)(E:\Typora笔记\java笔记\img\image-20220302090422374.png)]$

线程状态转换图【非常重要】

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TaKCzN6J-1646219231360)(E:\Typora笔记\java笔记\img\image-20220302090521469.png)]$

package thread_.state_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName()+"创建状态："+t.getState());
        t.start();
        System.out.println(t.getName()+"start后的状态："+t.getState());

        while(Thread.State.TERMINATED != t.getState()){
            Thread.sleep(500);
            System.out.println(t.getName()+"我是主线程！！！"+t.getState());
        }
        System.out.println(t.getName()+"中止后的线程："+t.getState());
    }
}

class T extends Thread{
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是中国人"+this.getState());
            }
            break;
        }
    }
}

线程的同步`Synchronized`

先看一个问题售票问题： 存在多卖的现象，引出了线程同步机制

线程同步机制

在多线程编程中，一些敏感数据不允许多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据完整性
也可以理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iHV4fPOo-1646219231360)(E:\Typora笔记\java笔记\img\image-20220302102241291.png)]$

同步具体方法实现`synchronized`

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

方式二：synchronized还可以放在方法声明中，表示整个方法为同步方法
public synchronized void m(String name){
// 当多个线程要执行M方法时，只能允许一个线程执行，它们轮流交替执行
	需要被同步代码
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JidcRY6R-1646219231361)(E:\Typora笔记\java笔记\img\image-20220302102705523.png)]$

package thread_.state_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class SellTicket {
    public static void main(String[] args) {
        T1 t = new T1();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}

class T implements Runnable {
    private int ticket = 100;
    private int count = 0;
    final Object t = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (t){
            if (ticket <= 0){
                break;
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"该窗口售票一张：还剩下"+(--ticket)+"张\t"+(++count));
        }
     }
    }
}

class T1 implements Runnable {
    private int ticket = 100;
    private boolean loop = true;// 修改值，使用run方法退出，结束线程
    private int count;
    @Override
    public void run() {
        while (loop){
            sell();
            //是一个同步方法，只能有一个线程执行，当所有线程进入RUn方法时，要调用sell方法时，只能让一个方法执行
        }
    }

    public synchronized void sell(){
        if (ticket <= 0){
            loop = false;
            return;
        }
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"该窗口售票一张，还剩下"+(--ticket)+"张  "+(++count));
    }
}

分析同步：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-En2dN8Rn-1646219231361)(E:\Typora笔记\java笔记\img\image-20220302112939074.png)]$

例如：当t1 t2 t3需要对同步代码块执行权，由于是synchronized修饰的，所以当t1抢到执行权，执行到时间，释放锁，t1 t2 t3三者又重新争执行权，因为是synchronized修饰的，不是公平锁

互斥锁

基本介绍：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lF0jFtu7-1646219231361)(E:\Typora笔记\java笔记\img\image-20220302114058543.png)]$

注意是：加入了synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问

同步方法是非静态的锁可以是this，也可以是其他对象【但是必须是同一个对象】

同步方法是静态的锁为当前类本身【就是类.class】

互斥锁的注意事项【必须记住】

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eIwMEdfP-1646219231361)(E:\Typora笔记\java笔记\img\image-20220302114732521.png)]$

使用互斥锁的方式来实现售票

package com.hspedu.syn;

/**
 * 使用多线程，模拟三个窗口同时售票100张
 */
public class SellTicket {
    public static void main(String[] args) {

        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里我们会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程


//        System.out.println("===使用实现接口方式来售票=====");
//        SellTicket02 sellTicket02 = new SellTicket02();
//
//        new Thread(sellTicket02).start();//第1个线程-窗口
//        new Thread(sellTicket02).start();//第2个线程-窗口
//        new Thread(sellTicket02).start();//第3个线程-窗口

        //测试一把
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();//第1个线程-窗口
        new Thread(sellTicket03).start();//第2个线程-窗口
        new Thread(sellTicket03).start();//第3个线程-窗口

    }
}


//实现接口方式, 使用synchronized实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    private boolean loop = true;//控制run方法变量
    Object object = new Object();


    //同步方法（静态的）的锁为当前类本身
    //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
    //2. 如果在静态方法中，实现一个同步代码块.
    /*
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
     */
    public synchronized static void m1() {

    }
    public static  void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }

    //老韩说明
    //1. public synchronized void sell() {} 就是一个同步方法
    //2. 这时锁在 this对象
    //3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
    public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法

        synchronized (/*this*/ object) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }

    @Override
    public void run() {
        while (loop) {

            sell();//sell方法是一共同步方法
        }
    }
}

//使用Thread方式
// new SellTicket01().start()
// new SellTicket01().start();
class SellTicket01 extends Thread {

    private static int ticketNum = 100;//让多个线程共享 ticketNum

//    public void m1() {
//        synchronized (this) {
//            System.out.println("hello");
//        }
//    }

    @Override
    public void run() {


        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));

        }
    }
}


//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum

    @Override
    public void run() {
        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2

        }
    }
}

线程的死锁

基本介绍：

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

应用案例：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nhEIAcRf-1646219231362)(E:\Typora笔记\java笔记\img\image-20220302120748271.png)]$

模拟死锁代码：

package thread_.state_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class DeadLock {
    public static void main(String[] args) {
        myT A = new myT(true);
        A.setName("A线程");
        myT B = new myT(false);
        B.setName("B线程");
        A.start();
        B.start();
    }
}


class myT extends Thread {
    private boolean flag;
    static Object o1 = new Object();//为共享变量用static修饰
    static Object o2 = new Object();

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

    @Override
    public void run() {
        if (flag == true){
            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");
                }
            }
        }
    }
}

package com.hspedu.syn;

/**
 * 模拟线程死锁
 */
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 Object o1 = new Object();// 保证多线程，共享一个对象,这里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {//构造器
        this.flag = flag;
    }

    @Override
    public void run() {

        //下面业务逻辑的分析
        //1. 如果flag 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
        //2. 如果线程A 得不到 o2 对象锁，就会Blocked
        //3. 如果flag 为 F, 线程B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
        //4. 如果线程B 得不到 o1 对象锁，就会Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁, 下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入2");
                }
                
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入4");
                }
            }
        }
    }
}

释放锁【记住】

下面的操作会释放锁

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

下面的操作不会释放锁

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

提示：应该尽量避免使用suspend()方法和resume()来控制线程，方法不再推荐使用

本章作业

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BPjaJZZc-1646219231362)(E:\Typora笔记\java笔记\img\image-20220302125650801.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XEwaHCLT-1646219231363)(E:\Typora笔记\java笔记\img\image-20220302132520285.png)]$

package thread_.homeWork_;

import java.util.Scanner;

/**
 * @author: 海康
 * @version: 1.0
 */
public class HomeWork01 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        Thread thread = new Thread(t1);
        thread.start();
        T2 t2 = new T2(t1);
        t2.start();
    }
}

class T1 implements Runnable{
    boolean loop = true;

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

    @Override
    public void run() {
        while (loop){
            // 打100内的随机整数
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println((Math.floor(Math.random() * 100) + 1));
        }
    }


}

class T2 extends Thread {
    T1 t1 = null;

    public T2(T1 t1){
        this.t1 = t1;
    }

    @Override
    public void run() {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入Q字符串！！");
            String s = sc.nextLine();
            char key = s.toUpperCase().charAt(0);
            if (key == 'Q') {
                t1.setLoop(false);
                System.out.println("T2线程结束！！！");
                break;
            }
        }
    }
}

package com.hspedu.homework;

import java.util.Scanner;


public class Homework01 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);//一定要注意.
        a.start();
        b.start();
    }
}

//创建A线程类
class A extends Thread {
    private boolean loop = true;

    @Override
    public void run() {
        //输出1-100数字
        while (loop) {
            System.out.println((int)(Math.random() * 100 + 1));
            //休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("a线程退出...");

    }

    public void setLoop(boolean loop) {//可以修改loop变量
        this.loop = loop;
    }
}

//直到第2个线程从键盘读取了“Q”命令
class B extends Thread {
    private A a;
    private Scanner scanner = new Scanner(System.in);

    public B(A a) {//构造器中，直接传入A类对象
        this.a = a;
    }

    @Override
    public void run() {
        while (true) {
            //接收到用户的输入
            System.out.println("请输入你指令(Q)表示退出:");
            char key = scanner.next().toUpperCase().charAt(0);
            if(key == 'Q') {
                //以通知的方式结束a线程
                a.setLoop(false);
                System.out.println("b线程退出.");
                break;
            }
        }
    }
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U8u3Wfja-1646219231363)(E:\Typora笔记\java笔记\img\image-20220302145943841.png)]$
在这里插入图片描述

package thread_.homeWork_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class HomeWork02 {
    public static void main(String[] args) {
        T t = new T();
        Thread thread1 = new Thread(t);
        Thread thread2 = new Thread(t);
        thread1.start();
        thread2.start();
    }
}

class T implements Runnable {

    private boolean loop = true;
    private int total = 10000;

    @Override
    public void run() {
        while (loop) {
            //方式一：
//            draw_money();

            //1. 这里使用 synchronized 实现了线程同步
            //2. 当多个线程执行到这里时，就会去争夺 this对象锁
            //3. 哪个线程争夺到(获取)this对象锁，就执行 synchronized 代码块, 执行完后，会释放this对象锁
            //4. 争夺不到this对象锁，就blocked ，准备继续争夺
            //5. this对象锁是非公平锁.
            // 方式二：建议使用这种方式效率高
            synchronized (this) {
                if (total < 1000) {
                    System.out.println("余额不足！！！");
                    break;
                }

                System.out.println(Thread.currentThread().getName()
                        +"您取款了1000元，还剩下 "+(total-=1000));
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void draw_money () {
        if (total <= 1000){
            System.out.println("余额不足！！！");
            loop = false;
            return;
        }
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("您取款了1000元，还剩下 "+(total-=1000));
    }
}

package com.hspedu.homework;


public class Homework02 {
    public static void main(String[] args) {
        T t = new T();
        Thread thread1 = new Thread(t);
        thread1.setName("t1");
        Thread thread2 = new Thread(t);
        thread2.setName("t2");
        thread1.start();
        thread2.start();
    }
}

//编程取款的线程
//1.因为这里涉及到多个线程共享资源，所以我们使用实现Runnable方式
//2. 每次取出 1000
class T implements  Runnable {
    private int money = 10000;

    @Override
    public void run() {
        while (true) {

            //解读
            //1. 这里使用 synchronized 实现了线程同步
            //2. 当多个线程执行到这里时，就会去争夺 this对象锁
            //3. 哪个线程争夺到(获取)this对象锁，就执行 synchronized 代码块, 执行完后，会释放this对象锁
            //4. 争夺不到this对象锁，就blocked ，准备继续争夺
            //5. this对象锁是非公平锁.

            synchronized (this) {//
                //判断余额是否够
                if (money < 1000) {
                    System.out.println("余额不足");
                    break;
                }

                money -= 1000;
                System.out.println(Thread.currentThread().getName() + " 取出了1000 当前余额=" + money);
            }

            //休眠1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

昱晟168

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
理解java多线程基础部分只需这篇文章

多线程基础线程相关概念程序program程序是静态，进行是动态是为完成特定任务，用某种语言编写的一组指令的集合。简单的理解就是我们写的代码进程1.进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用另外一个软件，又启动了一个进程，操作系统将另一个软件分配新的内存空间。2.进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生，存在和消亡的过程什么是线程1.线程由进程创建的，是进程的一个实体2.一个进程可以拥有多个线
复制链接

扫一扫