关于java中的线程

最新推荐文章于 2023-06-03 17:23:45 发布
最新推荐文章于 2023-06-03 17:23:45 发布
阅读量97 收藏
点赞数 1
分类专栏： Java 文章标签： jvm java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Smarmot/article/details/129582168
版权

一、基本介绍

什么是线程？

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

举个例子：

当我们使用迅雷的时候，迅雷就是一个进程，而当你每下载一部电影的时候，就会开启一个线程。

什么是进程？

进程就是指运行中的程序，如点击迅雷，就启动了一个进程，操作系统就会为迅雷分配内存空间。

线程相关概念：

  1. 并发：同一时刻，单核cpu(某一个cpu)在对多个任务进行交替执行。

  1. 并行：同一时刻，多核cpu(多个cpu)在对多个任务进行同时执行

注意：并发是对于一个cpu，并行则是对于多个cpu，在使用中并发和并行可同时存在

案例引入

在实际中，我们为了提高效率，可以使用多线程来处理事情，即同时处理多个任务。

举个大脑多线程的使用例子：

左手画圆，有手画矩形

那么在java中又如何使用多线程呢？

二、创建线程

通过继承Thread类

class A extends Thread{

}

此时我们还需要重写一个run()方法!

class A extends Thread{
    @Override
    public void run() {
        
    }
}

这样我们就具备了创建线程的条件了。下面我们创建线程

public class test01 {
    public static void main(String[] args) {
        A a = new A();
        a.start(); //开启线程
    }
}

class A extends Thread{
    @Override
    public void run() {

    }
}

注意：一定要在main()方法中通过start()方法，才能真正创建一个线程，如果直接调用run()方法是实现不了的(具体原因下面说明)。

通过实现Runnable接口

当然我们也要重写run()方法

class A implements Runnable{
    @Override
    public void run() {

    }
}

但是创建线程的方法就不一样了，因为Runnable这个接口他就一个run()方法，没有start()方法。

聪明java设计者于是就重载了一个Thread类的构造方法。

于是乎，我们现在可以通过创建一个Thread类对象，通过多态，来调用start()方法。

public class test01 {
    public static void main(String[] args) {
        A a = new A();
        Thread thread = new Thread(a);
        thread.start(); //我又创建出来拉~
    }
}

class A implements Runnable{
    @Override
    public void run() {

    }
}

两种实现方式的对比

  1. 通过继承Thread的方式，可以直接调用Thread类中方法

  1. 通过实现Runnable接口的方式，更加灵活，因为java只有单继承，这样你就可以继承其他重要的类辣。

思考：为什么不直接调用run()方法呢？

run()方法的本质就是一个普通的方法，没有真正的启动一个线程。

start()方法，他会去调用start0()方法，start0()方法是由JVM来调用的，内部源码看不到，不过肯定调用了run()方法，start0()的底层c/c++实现，就不再深究了，切勿走火入魔~

因此，真正实现多线程的是start0()方法，而不是run()方法。

浅析线程创建

为了常看输出结果，我们每输出一次就让他睡1s

public class test01 {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        Thread thread = new Thread(a);
        thread.start();

        for(int i = 0; i < 50; i++){
            System.out.println("main线程在运行~");
            Thread.sleep(1000);
        }
    }
}

class A implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("线程A在运行~");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }
}

创建示意图：

当我们对当前程序进行运行(run)的时候

首先开了一个进程，然后启动了一个main线程，在main线程中又开启了一个子线程-A线程。

注意：

当main线程执行完结束了，子线程并不会直接结束，进程也不会结束，而是等待其他线程都结束了，进程才会结束。当main线程启动了子线程，main线程不会不动(阻塞)，而是继续执行。

所以最终结果如下(线程A是死循环打印)：

线程终止

  1. 等线程完成任务，自动退出

  1. 通过修改线程某个变量，来控制run()方法，让他提前退出

案例：

public class test01 {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        Thread thread = new Thread(a);
        thread.start();
        Thread.sleep(2*1000);
        //通知线程终止
        A.setLoop();
    }
}

class A implements Runnable{
    private  static boolean loop = true;
    @Override
    public void run() {
        while(loop){
            System.out.println("线程A在运行~");

        }
    }

    public static void setLoop(){
        loop = false;
    }
}

三、线程常用方法

常用方法

1.start()

创建并执行该线程，底层是JVM调用该线程的start0()方法

2.run()

调用当前线程的run()方法

3.setName(Stringname)

设置线程的名称为name

4.getName()

获取线程的名称

5.sleep(long millis)

让线程休眠millis毫秒(但不会终止线程！)

6.interrupt()

中断线程

7.yield()

线程礼让，让出cpu，让其他线程执行，但是会根据实际情况来决定，礼让是否会成功(取决于当时cpu负载)

8.join()

线程插队。如果线程插队成功，则必须先执行完插入的线程中所有任务，才进行其他线程

守护线程

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

举个例子：

通过使用多线程，我们知道main线程结束后，创建的子线程并不会结束，如果此时我们想要让子线程结束该怎么办呢？

  1. 通过使用线程终止的方式，手动让线程终止

  1. 将线程设置为守护线程

如下：

public class test01 {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        Thread thread = new Thread(a);
        thread.setDaemon(true); //将线程设置为守护线程
        thread.start();
    }
}

class A implements Runnable{

    @Override
    public void run() {
        while(true){
            System.out.println("线程A在运行~");
            
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            
        }
    }
}

注意：设置守护线程的语句要先与创建的语句，当所有用户线程结束后，守护线程才会结束

thread.setDaemon(true); //一定要先于start()，不然会抛异常
thread.start();

四、线程的状态

JDK中用Thread中的State枚举类表示了6种线程的状态

NEW

尚未启动的线程处于此状态

RUNNABLE

在JAVA虚拟机中执行的线程处于此状态

BLOCKED

被阻塞等待监视器锁定的线程处于此状态

WAITING

正在等待另一个线程执行的线程处于此状态

TIMED_WAITING

正在等待另一个线程执行到指定等待时间的线程处于此状态

TERMINATED

已退出的线程处于此状态

如下代码可以看到除BOLCKED的状态：

public class test01 {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        System.out.println("线程A的状态：" + a.getState());
        a.start();
        for(int i = 0; i <5; i++){
            System.out.println("线程A的状态：" + a.getState());
            Thread.sleep(1000);
        }

        Thread.sleep(10* 1000);
        System.out.println("线程A的状态：" + a.getState());
    }
}

class A extends Thread{
    @Override
    public void run() {
        B b = new B();
        b.start();
        try {
            b.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        for(int i = 0; i < 5; i++){
            System.out.println("线程A正在执行~");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class B extends Thread{
    @Override
    public void run() {
        try {
            sleep(2*1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

五、线程同步机制

为什么要引入这个东西呢？

案例引入

现模拟一个学生选课系统，有多个学生来抢一门课。

public class test02 {
    public static void main(String[] args) {
        //模拟三个学生来抢
        GetClass getClass = new GetClass();
        new Thread(getClass).start();
        new Thread(getClass).start();
        new Thread(getClass).start();
    }
}

class GetClass implements Runnable{
    private int classnums = 20;
    @Override
    public void run() {
        while(true){
            if(classnums <= 0){
                System.out.println("课被抢完了~");
                break;
            }
            else{
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("恭喜"+ Thread.currentThread().getName() + "抢到了，"+ "现在还剩" + (--classnums) + "名额");
            }
        }

    }
}

输出结果如下：

我们会发现不仅有超名额，还有重复抢一个名额。

这是因为某一时刻，一下进去了好几个线程，同时抢，同时减~

所以我们就引入了线程同步机制(锁)。

基本介绍

在多线程编程时，有一些敏感数据不允许被多个线程同时访问，可以使用线程同步机制，保证在任何时刻，数据只能有一个线程访问，即当有一个线程在对内存操作时，其他线程都不能对这个内存操作。

基本用法

  1. 使用代码块

synchronized (对象){
      //需要被同步的代码
}

  1. 声明在方法中，表示整个方法同步

public synchronized void fun(){
    //需要被同步的代码
}

通过线程同步机制，就能很好的解决案例中出现的问题。

public class test02 {
    public static void main(String[] args) {
        //模拟三个学生来抢
        GetClass getClass = new GetClass();
        new Thread(getClass).start();
        new Thread(getClass).start();
        new Thread(getClass).start();
    }
}

class GetClass implements Runnable{
    private int classnums = 20;
    @Override
    public void run() {
        while(true){
            synchronized (this){
                if(classnums <= 0){
                    System.out.println("课被抢完了~");
                    break;
                } else{
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("恭喜"+ Thread.currentThread().getName() + "抢到了，"+ "现在还剩" + (--classnums) + "名额");
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

输出如下：

一点毛病都没有了~

Synchronized细节

1.在java中引入了对象互斥锁的概念，目的是为了保证共享数据的完整性，但会降低效率。

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

3.当某个对象被synchronized修饰的时候，一个线程访问了这个对象，那么它就有了这个互斥锁，即相当于拥有了这个对象的标记，此时该对象只能在同一时刻被一个对象所访问。

4.synchronized修饰非静态方法，锁的对象可以是this或其他对象

     public synchronized void fun(){
         
    }

5.synchronized修饰静态方法，锁的对象是当前类本身

class A extends Thread{
    public static void fun(){
        synchronized (A.class){

        }
    }
}

注意：

  1. synchronized修饰普通方法，默认锁对象为this

  1. synchronized修饰静态方法，默认锁对象为当前类

  1. 多线程锁的对象一定为同一个，否则锁了没用

死锁

举个例子：

小明对小王说：你先请我，我就请你。

小王对小明说：你先请我，我就请你。

于是就陷入死循环了。

创建一个死锁：

public class test01 {
    public static void main(String[] args) throws InterruptedException {
        DeadLockDemo deadLockDemo = new DeadLockDemo(true);
        DeadLockDemo deadLockDemo1 = new DeadLockDemo(false);
        deadLockDemo.start();
        deadLockDemo1.start();

    }
}

class DeadLockDemo extends Thread {
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;
    public DeadLockDemo(boolean flag){
        this.flag = flag;
    }

    @Override
    public void run() {
        if(flag){
            synchronized (o1){
                System.out.println("111");
                synchronized (o2){
                    System.out.println("222");
                }
            }
        }else{
            synchronized (o2){
                System.out.println("333");
                synchronized (o1){
                    System.out.println("444");
                }
            }

        }
    }
}

分析：一个线程想要获得o1对象的，才能执行下去，另一个线程想要获得o2对象的锁才能执行下去，两个线程都想要获得对象手中的锁，因此程序会卡在那。

所以一定要避免这种情况的发生。

最后

本人水平有限，如有问题，欢迎指出~

机智的土拨鼠
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java中的线程
m0_65203573的博客
08-05 2991
Java线程
java中关于线程的知识
贾超的博客
04-02 255
java中的多线程处理在java中，通过两种方式来实现多线程 1.继承Thread类。 通过继承Thread类来实现多线程的方法简单明了，但是他也有一个很大的缺点，那就是如果相应的多线程处理类已经继承了一个类，便无法再继承Thread类。所以我们一般情况下不采用这种方式来实现线程的编程。 2.实现Runnable接口 使用Runnable接口的方法
JAVA之多线程
qq_41906909的博客
06-07 187
一、程序、进程、线程 1. 程序(program) 概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。 2. 进程(process) 概念：程序的一次执行过程，或是正在运行的一个程序。 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 3. 线程(thread) 概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。 说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。 内存结构： 进
java线程
05-12 112
1、 进程与线程的区别    进程是程序的动态执行过程，它包括加载、执行完成代码。进程是系统进行资源分配和调度进程的单位，有独立的地址空间。各个进程之间无法实现资源共享。    线程是实现并发的一种有效方式，是CPU调度的方式。线程是在进程的基础上进行的一部分，依赖于进程而存在。同一个进程中的线程可以同时存在，同时运行。2、java实现现成的方式    2.1继承Thread类，重写run（）方法...
Java线程
sunyingboaini的博客
06-20 1万+
线程的使用
Java中线程思维导图
最新发布
05-31
Java中线程思维导图
Java多线程编程总结
01-31
下面的内容是很早之前写的，内容不够充实，而且是基于Java1.4的内容，Java5之后，线程并发部分扩展了相当多的内容，因此建议大家看上面的系列文章的内容，与时俱进，跟上Java发展的步伐。要认识多线程就要从操作系统...
java线程分析工具TDA
06-21
Java线程分析是Java开发中的重要环节，尤其是在处理性能优化、死锁排查或者并发问题时。TDA（Thread Dump Analyzer）是一款强大的Java线程分析工具，它能够帮助开发者深入理解应用在运行时的线程状态，包括线程的...
Java多线程下载器
09-26
在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O以及进度监控。 1. **线程**：在Java中，线程是程序执行的最小单位，每个线程负责一部分文件的下载任务。Java提供两种方式创建线程：...
java多线程进度条
02-10
为了在多线程中同步进度更新，我们可以利用synchronized关键字、wait()、notify()方法，或者使用Java并发库中的高级工具，如Semaphore、CyclicBarrier或CountDownLatch等。 一个简单的进度条实现可以采用共享变量...
一文搞懂Java多线程
Systemmax20的博客
07-02 618
一文搞懂Java多线程的运行机制，包括Java多线程创建、生命周期、线程调度、线程同步等。
JAVA线程的总结与分析
yhl15736773842的博客
06-03 231
解决线程安全问题，进程和线程的区别线程安全问题，线程的创建方式，第一种: 通过父类Thread中的getName()可以获取线程名称。必须为Thread的子类 第二种: 通过Thread类中的静态方法currentThread获取当前线程，getName()获取线程名。任意处获取线程名。
Java(6)-java线程
黄规速博客:学如逆水行舟，不进则退
04-23 1万+
线程是一个单独程序流程。多线程是指一个程序可以同时运行多个任务，每个任务由一个单独的线程来完成。也就是说，多个线程可以同时在一个程序中运行，并且每一个线程完成不同的任务。程序可以通过控制线程来控制程序的运行，例如线程的等待、休眠、唤起线程等。 一. 线程的基本知识 线程是程序运行的基本单位，一个程序中可以同时运行多个线程。如果程序被设置为多线程， 可以提高程序运行的效率和...
Java多线程【三种实现方法】
m0_49496327的博客
03-29 826
java多线程 并发与并行 并发：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行 并行：一组程序按独立异步的速度执行，无论从微观还是宏观，程序都是一起执行的。 对比：并发是指:在同一个时间段内，两个或多个程序执行，有时间上的重叠(宏观上是同时,微观上仍是顺序执行) 进程与线程 进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作
Java线程、Java多线程详细介绍
Doreamonx的博客
06-13 1732
Java线程
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6246
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
JAVA多线程详解（超详细）
七星太极阵的博客
08-05 2万+
线程简介，线程的创建方式，多线程并发问题
【java多线程编程】三种多线程的实现方式
热门推荐
taojin12的博客
01-01 4万+
文章目录前言进程与线程继承Thread类，实现多线程FAQ 为什么多线程的启动不直接使用run（）方法而必须使用Thread类中start（）方法呢？基于Runnable接口实现多线程Thread 与 Runnable 的关系Callable实现多线程线程运行状态 前言 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;在java语言最大的特点是支持多线程的开发（也是为数不多...
java之yield(),sleep(),wait()区别详解-备忘笔记
攻城师
12-23 3259
1、sleep() 使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。 例如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程...
java线程知识点汇总
jerryq的博客
02-20 3302
线程状态        线程的状态可以分为5种：新建new、可运行runnable、正在运行running、阻塞blocked和死亡dead。        新建new：当一个线程新建出来，例如 Thread thread = new Thread() 此时，线程状态就是new。        可运行Runnable：当新建的线程调用start方法，线程状态就变为runnable，此时线...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值