【Java基础】-- 第15章：多线程基础

已于 2022-11-07 20:07:49 修改
阅读量346 收藏 1
点赞数 1
分类专栏： Java 文章标签： java
于 2022-10-31 16:15:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46656857/article/details/127617837
版权

文章目录

Java基础

十五、多线程基础

线程介绍

程序

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

进程

  • 进程是指运行中的程序，如我们使用的QQ，就启动了一个进程，操作系统就会为该进程分配内存空间
  • 进程是程序的一次执行过程，或是正在运行的一个程序，是动态过程：有它自己的产生、存在和消亡的过程

线程

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

单线程

同一时刻，只允许执行一个线程

多线程

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

并发

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

并行

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

线程基本使用

创建线程的两种方式
  • 继承Thread类，重写run方法
  • 实现Runnable接口，重写run方法

image-20221031111144683

线程应用案例–继承Thread类

image-20221031133858670

package com.Chapter10.Thread_;

import sun.util.resources.cldr.aa.CurrencyNames_aa;

public class thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建一个Cat对象，可以当作线程使用
        Cat cat = new Cat();
        cat.start();  //启动线程
        //说明:当main线程启动一个线程Thread-0,主线程不会阻塞，会继续执行
        //这时主线程和子线程是交替执行
        System.out.println("主线程继续指向" + Thread.currentThread().getName());
        for(int i = 0;i < 10;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("Java" + (++times)+ Thread.currentThread().getName());
            //让线程休眠1秒
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(times == 80)
                break; //当times等于80，就退出线程
        }
    }
}
run方法和start方法

image-20221031134530536

image-20221031134417544

线程应用案例- 实现Runnable接口

1）java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然是不可能的了

2）Java设计者提供了另一种方法来创建线程，就是通过实现Runnable接口来创建线程

image-20221031140837874

package com.Chapter10.Thread_;

import sun.awt.windows.ThemeReader;

import java.util.function.DoublePredicate;

public class thread02 {
    public static void main(String[] args) {
//        Dog dog = new Dog();
//        //不能调用start
//        //dog.start();
//
//        //创建了Thread对象，把dog对象(实现Runnable),放入Thread
//        Thread thread = new Thread(dog);
//        thread.start();
//    }
        Tiger tiger = new Tiger();
        ThreadProxy threadProxy = new ThreadProxy(tiger);  //这里可以传入tiger是因为ThreadProxy传入的Runnable，而tiger继承Runnable
        threadProxy.start();

    }
}
class Animal{}
class Tiger extends Animal implements Runnable{

    @Override
    public void run() {
        System.out.println("老虎大叫...");
    }
}
//线程代理类
class ThreadProxy implements Runnable{
    private Runnable target = null; //属性，类型是Runnable

    @Override
    public void run() {
        if(target!=null){
            target.run(); //动态绑定，运行类型是传入的Tiger，所以最终返回老虎大叫
        }
    }
    public ThreadProxy(Runnable target){
        this.target = target;
    }
    public void start(){
        start0();  //真正实现多线程
    }
    public void start0() {
        run();
    }

}


class Dog implements Runnable{

    int count = 0;
    @Override
    public void run() {
        while(true){
            System.out.println("hhhh" + (++count) + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}
线程应用案例-多线程执行

image-20221031140949506

package com.Chapter10.Thread_;

//main线程启动两个子线程
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{

    int count = 0;

    @Override
    public void run() {
        //每隔1秒输出"hello,world"，输出10次
        while(true) {
            System.out.println("hello,world " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }if(count == 10)
                break;
        }

    }
}
class T2 implements Runnable{

    int count = 0;

    @Override
    public void run() {
        //每隔1秒输出"hello,world"，输出10次
        while(true){
            System.out.println("hi " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(count == 5)
                break;
        }

    }
}

image-20221031141909965

继承Thread和实现Runnable的区别

image-20221031142139395

image-20221031143019979

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
    @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
        }
    }
}

出现超卖的情况，线程同步问题

image-20221031143249825

image-20221031143002927

线程终止

基本介绍

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

2）还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

image-20221031143459677

package com.Chapter10.Thread_;

import sun.awt.windows.ThemeReader;

public class Thread04 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();
        //如果希望main线程去控制t1线程的终止，必须可以修改loop
        //让t退出run方法，从而终止t线程 ->通知方式

        //让主线程休眠10秒，再通知t线程退出
        Thread.sleep(10*1000);
        t.setLoop(false);
    }
}
class T extends Thread{
    //设置一个控制变量
    private boolean loop = true;

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

    @Override
    public void run() {
        while(loop){
            try {
                Thread.sleep(50); //让当前线程休眠50ms
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("T运行中....");
        }

    }
}

线程常用方法

常用方法

1）setName：设置线程名称，使之与参数name相同

2）getName：返回该线程的名称

3）start：使线程开始执行，Java虚拟机底层调用该线程的start0方法

4）run：调用线程对象run方法

5）setPriority：更改线程的优先级

6）getPriority：获取线程的优先级

7）sleep：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

8）interrupt：中断线程

注意事项：

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

  • 线程优先级的范围

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

    image-20221031145443118

  • sleep：线程的静态方法，使当前线程休眠

image-20221031150547936

用户线程和守护线程

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

2）守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

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

image-20221031151526307

image-20221031151740683

线程的生命周期

image-20221031151856654

image-20221031152321130

Synchronized

线程同步机制

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

2）也可以理解为：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对内存地址进行操作

image-20221031153150435

同步原理

image-20221031154144808

互斥锁

基本介绍：
1）Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性

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

3）关键字synchronized来与对象的互斥锁联系，当某个对象用synchronized修饰时，表面该对象在任一时刻只能由一个线程访问

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

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

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

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
        }
    }
}

注意事项

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

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

3）实现落地步骤：

  • 需要先分析上锁的代码
  • 选择同步代码块或同步方法
  • 要求多个线程的锁对象为同一个
线程的死锁

基本介绍：

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

image-20221031160639008

释放锁

image-20221031160901576

image-20221031160926143

小d<>
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算机后端-Java-Java核心基础-第19章 IDEA的使用与多线程 15. 继承方式的课后练习.avi
05-22
计算机后端-Java-Java核心基础-第19章 IDEA的使用与多线程 15. 继承方式的课后练习.avi
java第11次作业
weixin_34061555的博客
12-02 1163
一. 本周学习总结 1.1 以你喜欢的方式（思维导图或其他）归纳总结多线程相关内容。 二. 书面作业 本次PTA作业题集多线程 1. 源代码阅读：多线程程序BounceThread 1.1 BallRunnable类有什么用？为什么代码中需要调用Thread.sleep进行休眠？ 答：BallRunnable类是支持多线程的类，开启了一个程序，使小球按照指定的规则移动，然后画出来获得小球的形状。...
Java线程问题
HJHKAW的博客
05-17 30
在Main方法中启动一个线程t1本题也可使用Lambda表达式实现。
jmu-Java-07多线程-Runnable与匿名类
qq_hua_xia的博客
10-27 1161
题目详情： 6-1 jmu-Java-07多线程-Runnable与匿名类 (10 分) 在Main方法中启动一个线程t1，该线程输出3行信息： 主线程名 线程t1的线程名 线程t1所实现的所有接口。提示：使用System.out.println(Arrays.toString(getClass().getInterfaces()));输出。 注：本题也可使用Lambda表达式实现。 裁判测试程序： public class Main { public static void
Java 基础入门 | 第十五章 Java多线程
洛阳泰山的博客
02-20 686
目录 线程的概念 线程的使用 线程的状态 线程同步问题 死锁和解决办法 线程的概念 什么是线程 在一个程序中同时运行的多个独立流程，每一个独立的流程就是一个线程线程并发 多个线程并发执行主线程 CPU 优先级 时间片 资源 当JVM启动之后，加载类文件，发现main方法，那么就会为main方法创建一个线程，用于main方法执行，这个为main方法创建的线程称为主线程 线程的使用 在Java中创建线程的方法有两种 方法一 继承java.lang.Thread类 方法二...
java 多线程（Callable，Future）
李响
11-01 732
package step2; import java.util.concurrent.Callable; import java.util.concurrent.FutureTask; public class Task { public void runThread(int num) { // 在这里开启线程 获取线程执行的结果 //请在此添加实现代码 /...
计算机后端-Java-Java核心基础-第20章 多线程 15. 线程通信的例题.avi
05-22
计算机后端-Java-Java核心基础-第20章 多线程 15. 线程通信的例题.avi
Java基础-经典入门教程
11-27
17. **多线程**：Java支持多线程编程，允许多个任务同时执行，提高程序效率。通过实现Runnable接口或继承Thread类可以创建线程。 18. **反射**：反射机制允许程序在运行时动态获取类的信息并操作类的对象，提供了...
java基础--微学院
05-04
9. **多线程**：Java内置对多线程的支持，可以通过实现Runnable接口或继承Thread类来创建线程，理解并发执行的概念和同步控制（如synchronized关键字、wait/notify机制）。 10. **文件和文件系统操作**：Java提供了...
java第15章java-chapter15.rar
最新发布
06-26
Java编程语言是面向对象的、跨平台...这些只是Java第15章可能涵盖的一些主题，实际的内容可能会根据不同的教材或教程有所调整。深入学习这些概念将有助于理解Java的精髓，提升编程能力，并为解决复杂问题打下坚实基础。
使用java理解程序逻辑第十五章
05-06
java入门基础，入门宝典，新手学习必备，好东西不容错过！
第十五章Java
2201_75658999的博客
10-20 50
想要永久的储存程序创建的数据，就需要将其保存在磁盘文件中，而中只有数据储存起来才可以在其他程序中使用它们java的I/O技术可以将数据保存起来到文本文件中，二进制文件甚至是ZIP压缩文件，以达到永久性保存数据的要求 掌握I/O处理技术能够提高对数据的处理能力。程序运行期间，大部分数据都在内存中进行操作，当程序结束或者关闭时，这些数据将消失，如果需要将数据永久保存， 就可以使用到输入输出流与指定的文件建立连接，当需要的数据永久保存到文件中就需要使用。//创造文件对象 获取文件位置储存到file中。
第十五章Java并发集合
一名在校大三学习JAVA
08-15 1174
目录第一代线程安全集合类 HashTable与HashMap对比第二代线程非安全集合类第三代线程安全集合类 ConcurrentHashMap结构JDK1.7JDK1.8JDK8中的ConcurrentHashMap为什么使用synchronized来进行加锁？
多线程学习总结
qq_16657805的博客
09-30 278
为什么使用多线程 为了更高效的完成任务和利用CPU资源，现在的操作系统设计为多任务操作系统，而多进程和多线程是实现多任务的方式。 进程和线程 程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。 进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。-------生命周期 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径 同步和异步&并发和并行 同步：排队执行，效率低但是安全 异步：同时执行，效
Java基础教程：多线程(2)-----创建线程的第一种方式
Blue92120的博客
12-05 87
在Java中，实现多线程操作有两种方式，一种是继承java.lang包下的Thread类，覆写Thread类的run()方法，在run()方法中实现运行在线程上的代码。另一种就是实现java.lang.Runnable接口，同样是在run()方法中实现运行在线程上的代码。两种方式的区别在于，继承Thread类可以直接启动线程，实现Runnable接口不能直接启动线程，需要先创建Thread类的实例对象，通过Thread类的构造方法传入实现了Runnable接口的实例对象，然后通过Thread类来启动线程。因
使用Callable和Future创建线程
欧阳子遥的博客
11-22 2670
编程要求 请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下： 在runThread(int num)函数中执行线程，创建Callable线程，Callable线程需要执行求第num项斐波那契数列的值，最后在runThread函数中获取Callable线程执行的结果，并打印输出。 斐波那契数列（Fibonacci数列） 这个数列从第3项开始，之后的每一...
Java第十五章
xy164914506的博客
10-21 45
OutputStream 类是字节输出流的抽象类，此抽象类是表示输出字节流的所有类的超类。如果需要将数据永久保存，可使用文件输入/输出流与指定的文件建立连接，将需要的数据永久保存文件中。如果需要将数据永久保存，可使用文件输入/输出流与指定的文件建立连接，将需要的数据永久保存文件中。中读取源中的数据，输出流的指向是数据要到达的目的地,程序通过向输出流中写入数据把信息传递到目的地，。缓存流为 I/O 流增加了内存缓存区，使得再流上执行 skip()、mark()、和 reset()方法成为可能。
试试多线程
qq_51482719的博客
12-01 479
5-19 本题要求主线程退出时，在main方法中所启动的线程t1也要自动结束。 public class Main { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(new PrintTask()); t1.setDaemon(true); t1.join(); System.out.println(Thread.
Java6&Java7&Java8
H0llyLiang的博客
06-29 1401
6-1 创建一个直角三角形类实现IShape接口 (10分) 创建一个直角三角形类（regular triangle）RTriangle类，实现下列接口IShape。两条直角边长作为RTriangle类的私有成员，类中包含参数为直角边的构造方法。 interface IShape {// 接口 public abstract double getArea(); // 抽象方法 求面积 public abstract double getPerimeter(); // 抽象方法 求周长 } 直角三角形
Java入门作业15 - 多线程基础 第3关：使用多线程方式求累加和
05-27
好的，我可以帮你解答关于Java多线程的问题。针对你的问题，可以使用多线程方式求累加和，具体实现如下： ```java public class SumThread extends Thread { private int start; private int end; private int ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值