Java笔记之线程（二十四）

最新推荐文章于 2023-07-20 12:11:11 发布
最新推荐文章于 2023-07-20 12:11:11 发布
阅读量179 收藏
点赞数
分类专栏： 自学Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44604159/article/details/124691679
版权

学习目录

一、线程基本概念

程序

其实就是我们写的代码

进程

进程是指正在运行的程序 如：电脑运行的QQ，就是一个进程

线程

线程由进程创建的，是进程的一个实际运作单位；一个进程可以拥有多个线程

单线程

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

多线程

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

并发

同一时刻，多个任务交替执行，有一种“貌似同时”的感觉，简单说就是单核cpu实现的多任务

并行

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

二、线程基本使用☆

1.创建线程

线程结构图
在这里插入图片描述
线程创建

  • 方式一：继承Thread类，重写run方法
  • 方式二：实现Runnable接口，重写run方法

2.快速入门

继承Thread类
要求：编写一个程序，开启一个线程，每隔一秒，输出“JAVA”，当输出3次后结束该线程

public class test {
    public static void main(String[] args) throws InterruptedException {
        test1 test1 = new test1();
        test1.start();      //启动线程 -> 执行test1的run方法
        for (int i = 0; i < 3; i++) {
            System.out.println("主线程 "+Thread.currentThread().getName());    //主线程和子线程是交替执行..不会出现阻塞现象
            Thread.sleep(1000);
        }
    }
}

class test1 extends Thread{
    int sum = 0;
    //该run方法并不是Thread类中的，而是Thread实现的Runnable接口中的run方法
    @Override
    public void run() {
        while (true){
            sum++;
            System.out.println("java 子线程 "+Thread.currentThread().getName());

            try {
                sleep(1000);    //睡眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (sum==3){
                break;
            }
        }
    }
}

实现Runnable接口
由于java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时如果需要继承Thread类显然是不可能的，所以可以通过实现Runnable接口

public class test {
    public static void main(String[] args) throws InterruptedException {
        test1 test1 = new test1();
        Thread thread = new Thread(test1);
        thread.start();
    }
}

class test1 implements Runnable{
    int sum = 0;
    //该run方法并不是Thread类中的，而是Thread实现的Runnable接口中的run方法
    @Override
    public void run() {
        while (true){
            sum++;
            System.out.println("java 子线程 "+Thread.currentThread().getName());

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

            if (sum==3){
                break;
            }
        }
    }
}

应用案例-多线程执行
要求：创建两个线程，一个线程每隔一秒输出 “java” 输出10次退出，另一个线程每隔一秒输出 “scala” 输出5次退出

public class test {
    public static void main(String[] args) throws InterruptedException {
        test1 test1 = new test1();
        test2 test2 = new test2();
        Thread thread = new Thread(test1);
        Thread thread1 = new Thread(test2);
        thread.start();
        thread1.start();
    }
}

class test1 implements Runnable{
    int sum = 0;
    @Override
    public void run() {
        while (true){
            sum++;
            System.out.println("java "+Thread.currentThread().getName());

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

            if (sum==10){
                break;
            }
        }
    }
}

class test2 implements Runnable{
    int sum = 0;
    @Override
    public void run() {
        while (true){
            sum++;
            System.out.println("scala "+Thread.currentThread().getName());

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

            if (sum==5){
                break;
            }
        }
    }
}

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

三、线程的同步

1.问题引入

使用多个线程模拟三个售票窗口，对100张票进行出售

Thread方式

public class test {
    public static void main(String[] args) throws InterruptedException {
        test1 test1 = new test1();
        test1 test2 = new test1();
        test1 test3 = new test1();
        test1.start();
        test2.start();
        test3.start();
    }
}

class test1 extends Thread{
    private static int sum = 100;
    @Override
    public void run() {
        while (true){

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

            try {
                Thread.sleep(50);    //睡眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (sum<=0){
                System.out.println("售票结束");
                break;
            }
        }
    }
}

Runnable接口

public class test {
    public static void main(String[] args) throws InterruptedException {
        test1 test1 = new test1();
        new Thread(test1).start();
        new Thread(test1).start();
        new Thread(test1).start();
    }
}

class test1 implements Runnable{
    private static int sum = 100;
    @Override
    public void run() {
        while (true){

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

            try {
                Thread.sleep(50);    //睡眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (sum<=0){
                System.out.println("售票结束");
                break;
            }
        }
    }
}

运行结果如下，可以看出当售票结束以后，其他窗口仍在售票，这里就出现了线程同步的问题
在这里插入图片描述

2.线程终止

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

public class test {
    public static void main(String[] args) throws InterruptedException {
        test1 test1 = new test1();
        test1.start();
        //让主线程休眠5秒
        Thread.sleep(5*1000);
        test1.setLoop(false);
    }
}

class test1 extends Thread{
    private int sum =0;
    //设置一个控制变量
    private boolean loop =true;
    @Override
    public void run() {
        while (loop){
            try {
                Thread.sleep(50);    //睡眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"..."+ ++sum);
        }
    }

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

四、线程的常用方法

1.第一组常用方法

方法名功能
setName设置线程名称
getName返回该线程的名称
start使该线程开始执行
run调用线程对象
setPriority更改线程的优先级
getPriority获取线程的优先级
sleep在指定的毫秒数内让当前正在执行的线程休眠
interrupt中断线程（注意：是中断而不是中止，相当于循环结构中continue）
public class test {
    public static void main(String[] args) throws InterruptedException {
        test1 test1 = new test1();
        test1.start();
        test1.setName("张三");

        //主线程执行五秒后，执行test1.interrupt();语句
        //由于主线程和test1线程同时进行，此时test1线程正在休眠执行test1.interrupt();以后将被唤醒
        for (int i = 0; i < 5 ; i++) {
            Thread.sleep(1000);
            System.out.println("主线程..."+i);
        }
        test1.interrupt();  //中断test1线程的休眠
    }
}

class test1 extends Thread{
    @Override
    public void run() {
        while (true){
            //输出0到99
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"..."+i);
            }
            try {
                Thread.sleep(20000);    //休眠20秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt时，就会catch一个异常，可以加入自己的业务代码
                System.out.println(Thread.currentThread().getName()+"被interrupt中断休眠了");
            }
        }
    }
}

在这里插入图片描述

2.第二组常用方法

方法名功能
yield线程的礼让。让出cpu，让其它线程执行，但礼让的时间不确定，所以也不一定礼让成功
join线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

join案例：子线程和主线程同时运行，当主线程输出五次以后让子线程运行，子线程运行完以后再执行子线程

public class test {
    public static void main(String[] args) throws InterruptedException {
        test1 test1 = new test1();
        test1.start();

        for (int i = 0; i < 20; i++) {
            Thread.sleep(1000);    //休眠1秒
            System.out.println("主线程..."+i);     //此时子线程和同时运行
            if (i==5){
                System.out.println("子线程先执行完，然后主线程再执行");
                test1.join();
            }
        }
    }
}

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

3.用户线程和守护线程☆

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

public class test {
    public static void main(String[] args) throws InterruptedException {
        test1 test1 = new test1();
        test1.setDaemon(true);  //将子线程设置为守护线程，当主线程结束后子线程自动结束，如果不设置守护线程则子线程将一直无限循环
        test1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程...");
            Thread.sleep(1000);
        }
    }
}

class test1 extends Thread{
    @Override
    public void run() {
        for (;;) {  //无限循环
            System.out.println(Thread.currentThread().getName()+"子线程...");
            try {
                Thread.sleep(1000);    //休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4.注意事项

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

五、线程的生命周期

在这里插入图片描述

其中RUNNABLE：可以分为就绪状态和运行状态。

王博1999
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java 多线程总结笔记
N0tExpecterr0r的博客
09-19 4310
Java多线程总结笔记 实现多线程的方法 查看Thread类的源码，可以发现它实现了Runnable接口，然后在自己的run方法中调用了Runnable的run方法。这里其实就是静态代理这一设计模式，Thread是代理角色，而Runnable则是真实角色。在Thread的start方法中，会为我们开辟新的线程并执行其run方法，而Thread的run方法会调用它内部持有引用的Runnable的ru...
java struts2学习笔记之线程安全
09-02
主要为大家详细介绍了java struts2学习笔记之线程安全，感兴趣的朋友可以参考一下
java多个数据库实现数据同步
03-16
内部java实现多个数据库，保持数据同步案例。
java实现csv导出千万级数据实例
07-31
轻松解决普通poi形式导出Excel的中出现的栈溢出问题，此资源可实现千万级数据分批导出csv文件，测试实现16500000条数据大概80秒左右；具体表里内容。
Java 面经手册·小傅哥.pdf
01-26
这是一本以面试题为入口讲解 Java 核心内容的技术书籍，书中内容极力的向你证实代码是对数学逻辑的具体实现。当你仔细阅读书籍时，会发现Java中有大量的数学知识，包括：扰动函数、负载因子、拉链寻址、开放寻址、斐波那契（Fibonacci）散列法还有黄金分割点的使用等等。 适合人群 1. 具备一定编程基础，工作1-3年的研发人员 2. 想阅读 Java 核心源码，但总感觉看不懂的 3. 看了太多理论，但没有实践验证的 4. 求职面试，总被面试题搞的死去活来的
java快速插入千万级数据
05-25
java快速插入千万级数据，亲测91秒插入1700万数据！！！
java一次性查询处理几百万数据解决方法
02-27
java一次性查询处理几百万数据解决方法 几百万数据是可以处理的 暂时还没试过几千万级的数据处理
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3184
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java多线程之synchronized
qq_35716085的博客
07-20 6167
synchronized具有同步功能，是一种互斥锁，锁的是对象。如果既想保证共享变量的可见性和有序性，又想保证原子性，那么synchronized关键字是一个不错的选择。synchronized的缺点：1.synchronized底层是由jvm实现，因此不能手动控制锁的释放，不如lock锁灵活，synchronized修饰的方法一旦出现异常，jvm保证锁会被释放（lock锁需要在finally中释放）。2.synchronized是非公平锁，不保证公平性。
万字图解Java多线程
qq_35598736的博客
09-06 5万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Thinking in Java读书笔记
热门推荐
yjclsx的博客
07-31 42万+
Thinking in Java读书笔记（IO和并发除外） 1.1、类中所有的private方法都隐式地指定为final的，由于其他类无法取用private方法，所以也就无法覆盖它；private方法无法被重写，继承对应private的方法无效，private的属性也无法拿到，但我们通常private的属性有对应的get、set方法，通常是public的，所以子类继承后可以调用方法来取得到父类的...
黑马程序员–Java多线程讲解笔记
12-22
当一个进程中线程有多个时，是多线程。 　为什么要用多线程 　1，让计算机"同时"做多件事情，节约时间。 　2，后台运行程序，提高程序的运行效率.。 　3，多线程可以让程序"同时"处理多个事情。 　4，...
Java多线程源码笔记.pdf
05-08
1.什么是多线程 2.Thread类解析 3.使用多线程需要注意的问题 4.synchronized锁和lock锁 5.AQS 6.ReentrantLock和ReentrantReadWriteLock 7.线程池 8.死锁 9.线程常用的工具栏 10.Atomic 11.ThreadLocal
java学习笔记 – 线程安全问题操作实例
12-22
一.并发与并行 了解线程之前我们需要知道并发和并行的概念。 并发：指两个或多个事件在同一个时间段内发生。 并行：指两个或多个事件在同一时刻发生...一个进程 中是可以有多个线程的，这个应用程序也可以称之为多
java多线程学习笔记之自定义线程池
08-29
本篇文章主要介绍了java多线程学习笔记之自定义线程池 ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
华为笔试题
流彩飞霞的专栏
09-03 4万+
1.写出判断ABCD四个表达式的是否正确, 若正确, 写出经过表达式中 a的值(3分) int a = 4; (A)a += (a++); (B) a += (++a) ;(C) (a++) += a;(D) (++a) += (a++); a = ? 答：C错误，左侧不是一个有效变量，不能赋值，可改为(++a) += a; 改后答案依次为9,10,10,11 2.某32位系统下, C
java 1秒_java线程:每隔一秒输出一个数据
weixin_28871743的博客
02-20 819
public static void main(String[] args) {BlockingQueue queue = new LinkedBlockingQueue();ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 1, TimeUnit.DAYS, queue);for (int i = 0; i < 20; i...
Java04
weixin_42806695的博客
11-29 201
Java笔记
多线程基础
Serendipity的博客
03-02 738
1. 线程相关的概念 程序：是为了完成特定的任务，用某种语言编写的一组指令的集合，简单的来说就是我们的代码。 进程：进程时指运行中的程序，比如QQ，启动QQ就启动了一个进程，操作系统就会为该进程分配内存空间。进程时程序的一次执行过程，或是正在运行的一个程序。是动态的过程，它有自身的产生、存在、消亡的过程。 线程：线程由进程创建，是进程的一个实体，一个进程可以拥有多个线程。 单线程：同一时刻，只允许执行一个线程。 多线程：同一时刻，可以执行多个线程，例如QQ可以打开多个窗口。一个迅雷可以下载多个文件/软件
狂神说java多线程笔记
最新发布
10-11
狂神在他的Java多线程笔记中，详细介绍了Java多线程的相关知识，包括线程的创建、启动、停止、等待、唤醒等操作，以及线程安全、锁、同步等概念和技术。 在Java多线程中，线程的创建有两种方式：继承Thread类和实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王博1999

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值