Java基础-多线程详解（基础中的基础，大佬可以忽略）

最新推荐文章于 2022-08-24 15:51:58 发布
最新推荐文章于 2022-08-24 15:51:58 发布
阅读量174 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32904533/article/details/115223019
版权
本文详细介绍了Java中的线程概念，包括任务、进程、线程和多线程，以及线程的创建方法，如继承Thread类、实现Runnable接口和Callable接口。讨论了线程的状态管理，如线程停止、休眠、礼让和join方法。同时，讲解了线程同步的重要性，包括死锁、同步方法和锁机制。最后，通过实例展示了线程同步问题，如线程不安全的购票场景和死锁问题。
摘要由CSDN通过智能技术生成

1.1线程简介

1.1.1任务，进程，线程，多线程

  • 任务
    一段时间内做的事情
  • 进程
    在操作系统运行的程序就是进程，一个程序执行时，内存会开辟一段空间。
    程序：指令和数据的有序集合，静态的概念
  • 线程
    一个进程可以包含有若干个线程，一个进程至少有一个线程
    线程是cup调度和执行的单位
  • 多线程
    多线程调运图（来自狂神说java）在这里插入图片描述

1.2线程创建

1.2.1 继承thread类

自定义线程类继承Thread类
重写run方法，编写线程方法体
创建线程对象，调用start（）方法启动线程

1.2.2 实现runnable接口（静态代理）

定义MyRunnable类实现Runnable接口
实现run（）方法，编写方法体
创建线程对象，电泳start（）方法启动线程
避免单继承的局限性，方便同一个对象被多个线程使用

1.2.3 实现callable接口

实现Callable接口，需要返回值类型
重写call方法，需要抛出异常
创建目标对象
创建执行服务 ExecutorService ser = Excutors.newFixedThreadPool(1);
提交执行：Future <Boolean> result = ser.submit(t1);
获取结果 boolean r1 = result1.get()
关闭服务 ser.shutdownNow()

简单龟兔赛跑练习

public class Race implements  Runnable{

    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <=100 ; i++) {

            if ("rabbit".equals(Thread.currentThread().getName())){
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("exception in race thread sleep function");
                }
            }

            if (gammeOver(i)){
                break;
            }
            System.out.println(Thread.currentThread().getName()+" is running the step :"+i);
        }
    }
    public static void main(String[] args) {
        Race race =new Race();
        Thread rabbit = new Thread(race,"rabbit");
        Thread turtle = new Thread(race,"turtle");
        rabbit.start();
        turtle.start();


    }
    private boolean gammeOver(int step){
        if (winner!=null){
            return true;
        }{
            if (step==100){
                winner = Thread.currentThread().getName();
                System.out.println("Winner is : "+winner+" Game over!" );
                return true;
            }
        }
        return false;
    }
}

1.3静态代理

真实对象与代理对象都需要同一个接口
代理对象要代理真实角色，需要将真实对象（目标）传入
好处：代理对象可以扩展功能，做甚多真实对象做不了的事情

public class StaticProxy{
    public static void main(String[] args) {
        //the class which implement the runnable interface ;
        You you = new You();
        //Thread thread = new Thread(object);
        WeddingCompany weddingCompany= new WeddingCompany(you);
        //thread.start();
        weddingCompany.marry();
    }
}

interface Marry {
public void marry();

}
class You implements Marry{


    @Override
    public void marry() {
        System.out.println("Marry is happy");
    }
}

class WeddingCompany implements Marry{
    private   Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void marry() {
        before();
        target.marry();
        after();

    }

    private void after() {
        System.out.println("after , collection");
    }

    private void before() {
        System.out.println("before , prepare");
    }
}

1.4 线程状态

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.4.1停止线程

不推荐JDK提供的stop（），destroy方法
推荐线程自己停止下来
建议使用标志位来进行终止

1.4.2线程休眠

sleep(时间)指定当前线程阻塞毫秒数
sleep存在异常InteruptedException
spleep时间达到后线程进入就绪状态
sleep可以模拟网路延迟，倒计时等等
每个对象都有一个锁，sleep不会释放锁
演示：计时

public class TestSleep {
    public static void main(String[] args) {
        Date date = new Date(System.currentTimeMillis());
        int num = 10;
        try {
        while (true){
            Thread.sleep(1000);
            num--;
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            date= new Date(System.currentTimeMillis());
            if (num==0)
                break;
        }
         //   tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            num--;
            System.out.println(num);
            if (num==0)
                break;
        }
    }
}

1.4.3线程礼让

Thread.yield（）
礼让线程，让当前正在执行的线程暂停但不阻塞
将线程运行状态转为就绪状态
让CPU重新调度，礼让不一定成功，看CPU心情
懒得写了，直接截图
在这里插入图片描述

1.4.4 Join()

Join 合并线程，待此线程执行之后，其他线程才可以继续执行，其他线程阻塞（插队）

1.4.5线程观测状态

Thread.state
来自B站狂神

public class TestState {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            for (int i = 0; i <5 ; i++) {
                try {
                    Thread.sleep(500);
                    System.out.println("agrarehaet");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread.State state = thread.getState();//NEW
        System.out.println(state);
        thread.start();
        state = thread.getState();//RUNNABLE
        System.out.println(state);

        while (state != Thread.State.TERMINATED)
        {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();
            System.out.println(state);
        }
//TERMINATED

    }
}

1.4.6线程优先级

Java 提供一个线程调度器老监控程序中启动后进行就绪状态的所有线程，线程调度器按照优先级来决定调度哪个线程来执行
线程的优先级用数字表示，范围1-10
Thread.MIN_PRIORITY=1;
Thread.MAX_PRIORITY=1;
Thread.NORM_PRIORITY=5;
使用以下方式改变或获取优先级
.setPriority(int xxx);
.getPriority();
优先级低只是意味着获得调度的概率低，依据CPU调度情况而定，优先级高的概率会增高

1.4.7守护线程

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等带守护线程执行完毕
如后台记录日志，GC

public class TestDaemond {
    public static void main(String[] args) {
        God god = new God();
        YouSelf youSelf = new YouSelf();

        Thread thread = new Thread(god);
        thread.setDaemon(true);
        thread.start();
        new Thread(youSelf).start();
    }
}

//上帝
class God implements Runnable{

    @Override
    public void run() {

        while(true){
            System.out.println("God bless you");
        }
    }
}
//你
class YouSelf implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <36500 ; i++) {
            System.out.println("always alive");

        }
        System.out.println("+++++++++Good bye+++++++");
    }
}

2.1线程同步 -多个线程操作同一个资源

2.1.1 并发

同一个对象被多个线程所执行（抢票，取钱）
处理多线程问题是， 多个线程访问同一个对象，并且一些线程需要修搞这个对象，就需要用到线程同步。线程同步就是一种等待机制，多个需要访问的线程进入这个对象的等待池
形成队列，等待前面的对象线程使用完毕之后，下一个线程再使用

2.1.2队列和锁

由于同一进程的多个线程共享一块存储空间，在带来方便的同事，为了保证数据在方法中被访问的正确性，在访问时加入锁机制 synchronized，当一个线程获得对象的排他锁，独占资源，那么其他线程必须等待，使用后释放锁即可（排队上厕所）

  • 一个线程持有锁，会导致所有其他需要该资源锁的线程挂起
  • 在多线程的竞争下，加锁，释放锁或导致比较多的上下文切换和调度延时，引起性能问题
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。
//线程不安全
public class UnSafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicketStation = new BuyTicket();

        new Thread(buyTicketStation,"无能的我").start();
        new Thread(buyTicketStation,"牛逼的你").start();
        new Thread(buyTicketStation,"万恶的黄牛").start();
    }
}

class BuyTicket implements Runnable{

    private  int ticketsNum = 10;
    boolean flag = true;
    @Override
    public void run() {
        // sale ticket
        while (flag){
            buy();
        }
    }

    private void buy(){
        //if have tickets
        if(ticketsNum <= 0){
            System.out.println("no tickets now");
            flag=false;
            return;

        }
        //模拟延时
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        ticketsNum--;
        System.out.println(Thread.currentThread().getName()+"get the "+ ticketsNum);

    }
}

2.1.3同步方法

synchronized 方法控制对"对象"的访问，每一个对象对应一把锁，每个synchronized方法都必须获得电泳该方法的锁才能执行，否则线程阻塞，方法一旦执行则独占该锁，知道方法返回才释放锁，后面阻塞的线程参能获得这个锁继续执行
缺点：影响效率

  • 同步块：synchronized（obj）{}
  • obj 称之为同步监视器 obj可以是任何对象，推荐使用共享资源作为同步监视器
  • 同步方法中无需指定同步监视器，默认this，该对象或者是class
  • 同步监视器的执行过程
    • 第一个线程访问，锁定同步监视器，执行代码块
    • 第二个线程访问，发现同步监视器锁定，无法访问
    • 第一个线程访问完毕，解锁同步监视器
    • 第二个线程访问，发现监视器没u有锁，然后锁定并访问

2.1.4死锁

多个线程互相抱着对方所需要的资源，形成僵持状态
产生死锁的四个条件（缺一不可）

  • 互斥条件：一个资源每次只能被一个线程使用
  • 请求与保持条件： 一个进程因请求资源而阻塞，对已获得的资源保持不放
  • 不剥夺条件：线程已获得资源，在未使用完之前，不能强行剥夺
  • 循环的等待条件：若干线程之间形成一种头尾相接的循环资源等待
public class DeadLock {
    public static void main(String[] args) {
        MakeUp girl1 = new MakeUp(0, "灰姑娘");
        MakeUp girl2 = new MakeUp(1, "白雪公主");

        girl1.start();
        girl2.start();

    }
}

class Lipstick {

}

class Mirror {

}

class MakeUp extends Thread {
    private static Lipstick lipstick = new Lipstick();
    private static Mirror mirror = new Mirror();

    int choice;
    String name;

    public MakeUp(int choice, String name) {
        this.choice = choice;
        this.name = name;
    }

    @Override
    public void run() {
        if (choice == 0) {

            synchronized (lipstick) {
                System.out.println(this.name + " get the lock of lipstick");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (mirror) {
                    System.out.println(this.name + " get the lock of mirror");
                }

            }
        } else {
            synchronized (mirror) {
                System.out.println(this.name + " get the lock of mirror");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lipstick) {
                    System.out.println(this.name + " get the lock of lipstick");
                }

            }
        }
    }
}

2.1.5锁Lock

控制多个线程对共享资源的进行访问的工具，提供了对共享资源的独占访问，每次只能有一个线程对lock对象加锁，线程开始访问共享资源之前应先获得lock锁

Levi__Zhang
关注
Java设计模式大全：23种常见的设计模式详解（二）
凛鼕将至的博客
02-05 2172
​设计模式是一种解决常见软件设计问题的经验总结，它提供了一套可重用的设计思想和方法，帮助开发人员更好地组织和设计他们的代码。在软件开发中，我们经常会遇到一些常见的问题，比如如何实现代码的灵活性、可扩展性、可维护性和可复用性，以及如何减少代码的耦合性等。设计模式通过定义一些通用的解决方案来解决这些问题，从而提高代码的质量和可维护性。 设计模式的概念最早由四位名为Gang of Four（GoF）的作者提出，他们在《设计模式：可复用面向对象软件的基础》一书中总结了23种常见的设计模式。这些设
JVM笔记：Java虚拟机的字节码指令详解
verzqli的博客
10-29 1041
1.字节码 Java能发展到现在，其“一次编译，多处运行”的功能功不可没，这里最主要的功劳就是JVM和字节码了，在不同平台和操作系统上根据JVM规范的定制JVM可以运行相同字节码（.Class文件），并得到相同的结果。之所以被称之为字节码，是因为字节码文件由十六进制值组成，而JVM以两个十六进制值为一组，即以字节为单位进行读取。在Java中一般是用javac命令编译源代码为字节码文件，将java...
Java 基础--线程 锁 线程池
danfengw的博客
12-25 515
线程 1 概念 进程与线程的区别： 进程：是资源分配的最小单位 线程：是cpu调度的最小单位 进程是抢占处理机的调度单位，线程属于某个进程，共享其资源 线程只由堆栈寄存器 程序计数器 和 TCB组成 进程与线程的区别 线程不能看作独立应用，而进程可以看作独立应用 进程有独立的地址空间，相互不影响，而线程只是进程的不同执行路径 线程没有独立的地址空间，多进程的程序比多线程程序健壮 进程的切换比线程切换开销大 线程中start 与 run 方法的区别 start() 会创建一个新的子线程并启动 run（）只是T
理解 Thread.Sleep 函数
greystar的专栏
04-08 5787
转自http://www.cnblogs.com/ILove/archive/2008/04/07/1140419.html我们可能经常会用到 Thread.Sleep 函数来使线程挂起一段时间。那么你有没有正确的理解这个函数的用法呢？思考下面这两个问题：1、假设现在是 2008-4-7 12:00:00.000，如果我调用一下 Thread.Sleep(1000) ，在 2008-4-7
Thread.yield()和Thread.sleep(0)
斜阳雨陌
12-07 5640
关于Thread.yield()和Thread.sleep(0)的语义问题真是一个让人挠头的问题，翻了好多资料，在java6语言规范中看到了一段这样的描述： 重点在红框中，简而言之就是：sleep(0)和yield()的实现不需要任何可见的效果。那么在实现这两个函数的语义时就可以什么都不做，这取决于具体的JVM实现。后来再看java8的语言规范时发现红框内的提示被去掉了，官方给出了下面的解释： ...
Thread的Sleep方法详解，
rolic_的博客
06-19 2万+
/* 1.Thread.sleep(毫秒) 2.sleep方法是一个静态方法 3.该方法的作用：阻塞该线程，让给其他线程*/public class fuck4 { public static void main(String[] args) throws InterruptedException{ Thread t1=new professor(); t1.setName("t1"); t...
线程休眠,礼让
weixin_45970171的博客
11-02 761
线程休眠,礼让 线程休眠 sleep(时间)指定当前线程阻塞的毫米值 sleep存在异常InterruptedException; sleep时间达到后线程进入就绪状态 sleep可以模拟网络延迟（就是在run方法中加一个sleep方法就可以了），倒计时等 每一个对象都有一个锁，sleep不会释放锁； package com.Jinone.www; import java.text.SimpleDateFormat; import java.util.Date; public class TextS
Java学习-20211213
Komoribe_1212的博客
12-13 352
Java基础 一、变量 变量都是其程序的基本组成单位：变量有三要素（类型+名称+值） 变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)。 1.1 基本步骤 声明变量 int a; 赋值 a= 60; 使用 System.out.println(a); 也可以int a=60； 二、数据类型 每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间(字节)。 2.1 整数类型 2.1.1 细节 Java各
Java的ReentrantLock(可重入锁)详解上篇
lt_xiaodou的博客
08-24 3264
比如我们有两个线程A，B，第一个线程A已经获取到锁了，B在获取锁的时候肯定获取不到，则会把B包装成Node，然后加入到同步的等待队列中，此时队列中只有一个head头节点和线程B所在的Node节点，head头节点在初始化时，它的waitStatus等于0，在第一次循环时，把头节点的waitStatus更新为SIGNAL，也就是-1，第二次循环时，因为head节点额waitStatus等于-1，所以在第一个if时，直接返回了true，告诉我们可以把当前线程中断掉。
Java学习专栏！全网最牛！
weixin_70730532的博客
08-12 2652
00254:《SpringCloud Alibaba微服务实战十四 - SpringCloud Gateway集成Oauth2.0》00242:《SpringCloud Alibaba微服务实战二十四 - SpringCloud Gateway的全局异常处理》00251:《SpringCloud Alibaba微服务实战十五 - SpringCloud 容器化部署》00248:《SpringCloud Alibaba微服务实战十八 - Oauth2.0 自定义授权模式》00184:《TCP网络那点破事！..
Thread之sleep方法
热门推荐
feigeswjtu的专栏
12-03 12万+
为什么要用sleep，主要是为了暂停当前线程，把cpu片段让出给其他线程，减缓当前线程的执行。 方法的定义: public static void sleep(long millis); public static native void sleep(long millis) throws InterruptedException;通过定义可以看出sleep方法是本地方法，通过系统调用暂停
进程、线程、多线程
稀里糊涂的小龙女
01-22 2914
线程、进程、多线程、守护线程、静态代理模式、线程同步、死锁、Lock锁
java sleep的用法_Java sleep方法的作用（sleep()）
weixin_32940141的博客
02-12 1261
sleep() 方法的作用是在指定的毫秒数内让当前“正在执行的线程”休眠(暂停执行)。这个“正在执行的线程”是指 this.currentThread() 返回的线程。例 1下面通过一个案例来理解使用 sleep() 方法判断线程是否活动的标准。假设 MyThread10 线程类的代码如下：package ch14;public class MyThread10 extends Thread{@O...
Java线程休眠（sleep）示例
young4u
05-25 3万+
java.lang.Thread的sleep()方法能使当前线程暂停运行一段时间（单位毫秒）。需要注意的是，sleep()方法的参数不能为负，否则会抛出IllegalArgumentException异常。     除此之外，还有另一个方法sleep(long millis, int nanos)，该方法可用于使当前线程暂停millis毫秒nanos纳秒。需要注意的是，参数nanos的取值范围为
Java线程中的sleep方法详解
大白的成长之路
03-15 2万+
关于线程的sleep方法 static void sleep(long mills) 1、静态方法：Thread.sleep(1000); 2、参数是毫秒 3、作用：让当前线程进入休眠，进入“阻塞”状态，放弃占有CPU时间片，让给其他线程使用。 public class ThreadTest06 { public static void main(String[] args) { //让当前线程进入休眠，睡眠5秒 //当前线程是主线程！！! try
Java 中Sleep 用法
LANGZI7758521的专栏
11-09 4万+
Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。 当线程睡眠时，它睡在某个地方，在苏醒之前不会返回到可运行状态。 当睡眠时间到期，则返回到可运行状态。线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。睡眠的实现：调用静态
这个系统为基于_MATLAB的水果分级系统_，以橘子为例_，通过检测橘子的面积，直
10-01
这个系统为基于_MATLAB的水果分级系统_，以橘子为例_，通过检测橘子的面积，直径大小和色泽率饱满_shuiguofenji
基于Html与Ajax技术的2024年课程作业表格设计源码
10-01
该课程作业项目采用Html与Ajax技术实现，共计包含37个文件，其中Java源文件7个，JavaScript文件6个，CSS样式文件5个，Map文件4个，HTML文件2个，还包含1个Git忽略文件、1个JAR包文件、1个属性文件、1个Maven构建文件和1个命令行脚本文件。项目主要围绕Ajax表格设计展开，适合作为相关课程的学习和实践案例。
【超强组合】基于matlab樽海鞘算法SSA-BP-Adaboost数据分类预测【含Matlab源码 8185期】.zip
最新发布
10-01
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2023b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化-BP-Adaboost数据分类预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化-BP-Adaboost数据分类预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化-BP-Adaboost数据分类预测 4.4.3 灰狼算法GWO/狼群算法WPA优化-BP-Adaboost数据分类预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化-BP-Adaboost数据分类预测 4.4.5 萤火虫算法FA/差分算法DE优化-BP-Adaboost数据分类预测 4.4.6 其他优化算法优化-BP-Adaboost数据分类预测
Java基础：多线程详解与实战实例
接下来，文章着重讲解了如何在Java中创建线程。创建线程主要有两种方式：继承Thread类和实现Runnable接口。这两种方式都涉及到重写run()方法，该方法是线程实际执行的代码块。创建线程后，可以调用start()方法启动...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值