Java多线程篇

最新推荐文章于 2023-12-07 23:30:00 发布
最新推荐文章于 2023-12-07 23:30:00 发布
阅读量157 收藏
点赞数
分类专栏： 知识点 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42806958/article/details/116747560
版权

一.进程与线程的关系

1.进程（程序跑起来执行的过程）：可以理解为完成一个任务，是由系统分配的。
2.线程：去执行任务的人。
总结：一个进程可以包含多个线程，但至少包含一个线程，不然进程没有存在的意义。

二.核心概念

1.线程状态：new新生》start就绪》线程调度器调用运行》消亡或阻塞
2.当程序运行时即使没有主动创建线程：后台也会有多个线程，如程序的入口main()主线程，gc线程。
3.调度器：一个进程如果开辟了多个线程，线程的运行是由调度器来安排的，且不能干预。
4.优先权：每个线程都有优先权
5.守护线程：

三.创建线程的三种方式

1.继承Thread类：重写run方法，创建线程对象，调用start方法

public class TestThread1 extends Thread{
	
	//重写run方法：线程执行的任务
    @Override
    public void run(){
        for (int i=1; i<=2000; i++){
            System.out.println("自定义线程"+i);
        }
    }
    
	//创建线程对象，调用start方法：启动线程
    public static void main(String[] args) {
        new TestThread1().start();
    }

}

2.实现Runnable接口：重写run方法，创建线程对象后，通过代理对象Thread，调用start方法

public class TestThread2 implements Runnable{

    @Override
    public void run(){
        for (int i=1; i<=2000; i++){
            System.out.println("自定义线程"+i);
        }
    }
	
	//Thread：代理对象
    public static void main(String[] args) {
        new Thread(new TestThread2()).start();
    }

}

3.实现Callable接口并设置返回值类型：重写call方法并抛出异常，创建线程池，提交执行，获取结果并抛出异常，关闭连接池

public class TestThread3 implements Callable<Boolean> {

    @Override
    public Boolean call() throws Exception {
        for (int i=1; i<=2000; i++){
            System.out.println("自定义线程"+i);
        }
        return true;
    }

    @SneakyThrows
    public static void main(String[] args) {
     	//创建线程对象
        TestThread3 testThread3 =new TestThread3();
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Boolean> submit =executorService.submit(testThread3);
        //获取结果
        boolean res = submit.get();
        //关闭连接池
        executorService.shutdownNow();
    }

}

四.线程停止

1.使用标志位，定义一个标志位后利用循环条件，通过修改标志位使线程正常停止
2.不要使用stop或destroy等，jdk不建议的过时方法

public class TestStop implements Runnable{

    //标志位
    private boolean flag =true;

    @Override
    public void run() {
       int i =0;
       while (flag){
           System.out.println("死循环线程次数："+i++);
       }
    }

    //利用循环条件，通过修改标志位使线程正常停止
    public void stop (){
        this.flag =false;
    }

    public static void main(String[] args) {
        TestStop testStop =new TestStop();
        new Thread(testStop).start();
        for (int i=0;i<1000;i++){
            System.out.println("主线程循环次数："+i);
            //主线程循环900次时，停止死循环线程
            if (i==900){
                testStop.stop();
                System.out.println("死循环线程停止了");
            }
        }
    }

}

五.线程休眠

public class TestSleep {

    public static void main(String[] args) {
        down();
    }

    //模拟倒计时
    @SneakyThrows
    public static void down(){
        int num =10;
        while (true){
        	//线程睡眠时间以毫秒为单位
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }

六.线程礼让

原理：让线程由运行状态转为就绪状态，礼让不一定成功，看cpu线程调度器安排

public class TestYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始");
        //线程礼让
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止");
    }

    public static void main(String[] args) {
        TestYield testYield =new TestYield();
        new Thread(testYield,"a").start();
        new Thread(testYield,"b").start();
    }

}

七.线程插队

线程插队：强制执行此线程，其它线程等待，待此线程执行完成后再执行

ublic class TestJoin implements Runnable{

    @Override
    public void run() {
        for (int i=0; i <999; i++) {
            System.out.println("自定义线程插队来了"+i);
        }
    }

    @SneakyThrows
    public static void main(String[] args) {
        TestJoin testJoin =new TestJoin();
        Thread thread =new Thread(testJoin);
        thread.start();
        for (int i=0; i <300; i++) {
            //主线程循环200次时，让自定义线程插队
            if (i==201){
                thread.join();
            }
            System.out.println("主线程"+i);
        }
    }
    
}

八.线程状态

public class TestState {

    @SneakyThrows
    public static void main(String[] args) {
        Thread thread =new Thread(() ->{
            for (int i = 0; i < 3; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        //获取线程状态
        Thread.State state = thread.getState();
        System.out.println("新生状态"+state);

        //观察启动后状态
        thread.start();
        state = thread.getState();
        System.out.println("就绪状态："+state);

        //观察阻塞状态-就绪状态-消亡状态
        while (state !=Thread.State.TERMINATED){
            Thread.sleep(1000);
            state=thread.getState();
            System.out.println("阻塞状态-就绪状态-消亡状态："+state);
        }
    }

}

九.线程优先级

原理：线程调度器会根据优先级来“权重”先调度那个线程，优先级最大10-1最小，默认5

public class TestPriority implements Runnable{

    @Override
    public void run() {
        System.out.println("名字"+Thread.currentThread().getName()+"优先级"+Thread.currentThread().getPriority());
    }

    public static void main(String[] args) {
        TestPriority testPriority =new TestPriority();
        Thread t1 =new Thread(testPriority);
        Thread t2 =new Thread(testPriority);
        Thread t3 =new Thread(testPriority);
        //默认优先级：NORM_PRIORITY=5
        t1.start();
        //最大优先级：MAX_PRIORITY=10
        t2.setPriority(Thread.MAX_PRIORITY);
        t2.start();
        //最小优先级：MIN_PRIORITY=1
        t3.setPriority(Thread.MIN_PRIORITY);
        t3.start();
    }
    
}

十.守护线程

要领：守护线程需在启动前设置，否则无效
案例：主线程先消亡情况，但只要有一个用户线程未消亡，守护线程就会存活。

public class TestDaemon {
    public static void main(String[] args) {
        Thread thread =new Thread(new Guard());
        thread.setDaemon(true);
        thread.start();

        new Thread(new User()).start();

        for (int i = 0; i < 50; i++) {
            System.out.println("主线程心跳");
        }
    }
}
//守护线程
class Guard implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("守护线程心跳");
        }
    }
}
//用户线程
class User implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("用户线程心跳");
        }
    }
}

十一.多线程不安全案例

我们都知道ArrayList线程不安全：那就用多线程去操作ArrayList看看结果

public class TestArrayList {

    @SneakyThrows
    public static void main(String[] args) {
        List<String> list =new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(2000);
        //由于线程不安全：集合长度可能是10000，9999、9998、9997....
        System.out.println("集合长度："+list.size());
    }
}

十二.同步方法与同步块

同步锁：多线程访问同一个资源，加锁后会排队访问，同一时间内只有一个线程可以进行操作。

public class TestArrayList implements Runnable{
    
    /**
     * synchronized修饰的方法叫同步方法，作用域this，锁的是当前方法归属类的对象
     * 所以它锁的是TestArrayList类，而不是list集合
     */
    @SneakyThrows
    @Override
    public synchronized void run() {
        List<String> list =new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(2000);
        System.out.println("集合长度："+list.size());
    }

    public static void main(String[] args) {
        new Thread(new TestArrayList()).start();
    }

}

public class TestArrayList implements Runnable{

    @SneakyThrows
    @Override
    public void run() {//任务：创建一万个线程，往list里插入一万条数据
        List<String> list =new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                //同步块：可以锁任何变化的量,使用场景增删改
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(2000);
        System.out.println("集合长度："+list.size());
    }

    public static void main(String[] args) {
        new Thread(new TestArrayList()).start();
    }

}

十三.死锁

死锁发生条件：
1.多线程互相持有对方的锁，
2.资源只有一份出现僵持，需等待资源后才能运行，
此时会出现线程停止的死锁问题。

package com.baijun.utils.entity;

import lombok.SneakyThrows;

/**
 * 死锁：多线程互相持有对方的锁,且资源只有一份出现僵持需要等待拿到对方的资源后才能运行，从而出现线程停止的死锁问题。
 */
public class TestLock extends Thread{

    //资源只有一份
    static Lipstick lipstick =new Lipstick();
    static Mirror mirror =new Mirror();

    //选择
    int choice;
    //使用化妆的人
    String girlName;

    TestLock(int choice,String girlName){
        this.choice=choice;
        this.girlName=girlName;
    }
    @Override
    public void run(){
        //化妆
        makeup();
    }
    //化妆，互相持有对方的锁，需要拿到对方的资源
    @SneakyThrows
    private void makeup(){
        if (choice==0){
            synchronized (lipstick){//口红锁
                System.out.println(girlName+"口红锁");
                Thread.sleep(1000);
                synchronized (mirror){//镜子锁
                    System.out.println(girlName+"镜子锁");
                }
            }
        }else {
            synchronized (mirror){//镜子锁
                System.out.println(girlName+"镜子锁");
                Thread.sleep(2000);
                synchronized (lipstick){//口红锁
                    System.out.println(girlName+"口红锁");
                }
            }
        }
    }

    public static void main(String[] args) {
        TestLock testLock1 =new TestLock(0,"宝子");
        TestLock testLock2 =new TestLock(1,"小凤");
        testLock1.start();
        testLock2.start();
    }

}

//口红
class Lipstick{}

//镜子
class Mirror{}

十四.lock锁

package com.baijun.utils.entity;

import lombok.SneakyThrows;

import java.util.concurrent.locks.ReentrantLock;

/**
 * Lock：是显式锁需要手动开关，synchronized是隐式锁，出了作用域自动释放。
 * 优先顺序：Lock、同步代码块、同步方法
 */
public class TestLock2 {

    public static void main(String[] args) {
        TestLock3 testLock3 =new TestLock3();
        for (int i = 0; i < 3; i++) {
            new Thread(testLock3).start();
        }
    }
}

class TestLock3 implements Runnable{

    int ticketNums =10;//    票数

    //定于Lock锁：ReentrantLock可重入锁
   private final ReentrantLock lock =new ReentrantLock();

    @SneakyThrows
    @Override
    public void run() {//买票
        while (true){
            try {
                lock.lock();//加锁
                if (ticketNums>0){
                    Thread.sleep(1000);
                    System.out.println(ticketNums--);
                }else {
                    break;
                }
            }finally {
                lock.unlock();
            }
        }
    }

}
柏君~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java多线程编程实战指南(核心篇)
07-17
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了――如今...
java多线程之火车售票系统模拟实例
08-30
下面小编就为大家带来一篇java多线程之火车售票系统模拟实例。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
@SneakyThrows注解
qq_43842093的博客
03-12 3730
此注解虽神奇，但慎用。因为一旦用了，如果你的代码遇到了异常，那么在编码阶段你是无法感知的。如果你的代码里没有异常，然而却声明了该注解，反而会引起不必要的误会。还是得看一下注意事项参考，了解多了之后再决定用不用。否则遇到了问题，就麻烦了。
Java异常（二）：SneakyThrows注解的使用
欧阳方超的专栏
10-26 351
@SneakyThrows注解是一个方便的工具，可以简化Java异常处理的代码编写。通过使用它，可以将受检异常转换为非受检异常，减少了冗长的异常处理代码。
java中@SneakyThrows注解的作用？
gb4215287的博客
11-17 313
java中@SneakyThrows注解的作用？
Java多线程读取大文件
12-22
为了提高速度，自然还得用上多线程技术。 　接下来介绍一下实现思路以及相关的知识点。 　内容 　一、对文件分区 　为了充分利用多线程读取，需要把文件划分成多个区域，供每个线程读取。那么需要有一个算法来...
java虚拟机多线程进阶篇总结
08-25
在本篇内容里小编给大家整理了关于java虚拟机多线程进阶篇的相关知识点内容，有兴趣的朋友们跟着参考下。
Java多线程之多线程异常捕捉
09-03
在java多线程程序中，所有线程都不允许抛出未捕获的checked exception，也就是说各个线程需要自己把自己的checked exception处理掉，通过此篇文章给大家分享Java多线程之多线程异常捕捉，需要的朋友可以参考下
【Java用法】Lombok中@SneakyThrows注解的使用方法和作用
最新发布
No8g攻城狮的博客
12-07 1579
可能大家都会以为这个方法就是 new RuntimeException() 之类的。普通Exception类,也就是我们常说的受检异常或者Checked Exception会强制要求抛出它的方法声明throws，调用者必须显示的去处理这个异常。设计的目的是为了提醒开发者处理一些场景中必然可能存在的异常情况。所以渐渐的java程序员处理Exception的常见手段就是外面包一层RuntimeException，接着往上丢。而Lombok的@SneakyThrows就是为了消除这样的模板代码。
Java：希望每天叫醒你的不是闹钟而是梦想！
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
12-30 1万+
Java：希望每天叫醒你的不是闹钟而是梦想！ 代码设计 import java.awt.*; import java.util.Date; import javax.swing.*; public class Clock extends JComponent{ /** * */ private static final long ...
Lombok注解-@SneakyThrows
qq_40321119的博客
08-11 1520
@SneakyThrows注解的用途得从java的异常设计体系说起。 java中我们常见的2类异常。 1.普通Exception类,也就是我们常说的受检异常或者Checked Exception。 2.RuntimeException类，既运行时异常。 前者会强制要求抛出它的方法声明throws，调用者必须显示的去处理这个异常。设计的目的是为了提醒开发者处理一些场景中必然可能存在的异常情况。比如网络异常造成IOException。 但是现实，往往事与愿违。大部分情况下的异常，我们都是一路往外抛了事。（强
【java系列】java反射使用和实践
Think_and_work的博客
04-19 314
学习反射吧
Java-并发篇-08-实现异步的八种方式
Alan0517
03-23 520
在实际开发中，很多业务场景都需要使用到异步，因此列举以下常见得八种异步方式。
全量异常扑捉注解：@SneakyThrows
majunzhu的博客
09-19 7612
@SneakyThrows 大胆抛出已检查的异常，以前没有人抛出它们！ Overview @SneakyThrows可以用来偷偷抛出已检查的异常而不在方法的throws子句中实际声明这一点。当然，应该谨慎使用这种有争议的能力。由lombok生成的代码不会忽略，包装，替换或以其他方式修改抛出的已检查异常; 它只是伪造了编译器。在JVM（类文件）级别，无论方法的throws子句如何，都可以抛出所...
Lombok之@SneakyThrows使用
热门推荐
cauchy6317的博客
10-24 3万+
未完成
java线程简介（1）
Nothing
01-04 323
源地址 http://www.journaldev.com/1016/java-thread-example  作者 Pankaj   欢迎来学习Java 线程的例子，进程和线程是两基本的单元被执行，相比较来说在并发程序中更多的是关注的JAVA线程。    进程 一个进程是一个独立(self contained)的运行环境，它可以被看作一个程序或者一个应用，在一个程序中包含多个
2023java 多线程面试题
07-27
引用\[3\]:这是另一个非常经典的java多线程面试问题。这也是我刚开始写线程程序时候的困惑。现在这个问题通常在电话面试或者是在初中级Java面试的第一轮被问到。这个问题的回答应该是这样的，当你调用start()方法时...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

柏君~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值