java多线程学习

已于 2024-01-24 20:47:08 修改
阅读量55 收藏
点赞数
分类专栏： java探索之路 文章标签： java
于 2020-11-18 18:32:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29894575/article/details/109781594
版权

1. 进程和线程

1. 1进程和线程的概念

  • 进程是资源分配（CPU、内存）的基本单位，它是程序执行的一个实例，在程序运行时创建；程序运行时系统就会创建一个进程，并为它分配资源，然后把它放入线程队列，等待CPU的调度，当调度到它的时候，就会为它分配CPU时间片，程序开始真正运行。

  • 线程是程序执行的最小单位，它是进行的一个执行流，是CPU调度和分派的基本单位；一个程序的多个线程之间可以并发执行。

2. 线程的实现

2. 1 多线程的实现

多线程的实现有三种方法：实现Runnable接口，继承Thread类，实现Callable接口

2. 1. 1 实现Runnable接口

  • 先来看看Runnable源码：
@FunctionalInterface
public interface Runnable {       // Runnable 接口源码
      public abstract void run();
  }

以下是Runnable接口实现多线程：

public class Test3 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Test2(),"Test2_Thread");
        thread.start();             // 使线程进入线程队列等待调度
    }
}
class Test2 implements Runnable {              
    @Override
    public void run() {                   // 重写run()方法
        System.out.println(Thread.currentThread().getName() + " begin executing! ");
    }
}

Test2类实现了Runnable接口，然后其对象作为参数传给Thread的构造方法，我们再来看看Thread类部分源码：

public class Thread implements Runnable  {   //   java.lang.Thread
    private Runnable target;          // 引用构造方法参数中的Runnable
    private volatile String name;     // 线程名，若不设定则使用默认赋值
    
	public Thread(Runnable target, String name) {      // Thraed类的一个构造方法
        this(null, target, name, 0);
    }
    
    @Override                                // 重写run()方法
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

2. 1. 2 继承Thread类

java 8 新特性 lamda 公式 ,也称为闭包。

public class Test3 {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{
                System.out.println( Thread.currentThread().getName() + " begin executing! ");    // 使用了lamda公式，简洁了代码
        }, "Test3_thread");
        thread.start();
    }
}

2. 1. 2 实现Callable接口

//TODO

2. 2 关于run()和start()的区别

  • run()方法

方法内是线程要做的事情；

  • start()方法

在 start() 方法内部，JVM 将创建一个新的本地线程，并将其与 Thread 对象关联。然后，JVM 调用本地方法，该本地方法会执行新线程的 run() 方法。这样，新线程会在独立的执行流中执行 run() 方法的代码。

2. 3 线程的五种状态

  • 新建 : 线程创建后就为新建状态（ 例如 调用构造器 new Thread( ) ），此时具有相应的内存空间和其他资源，但还处于不可运行阶段；

  • 就绪：通过调用线程对象的 start() 方法可以使线程进入就绪阶段，线程加入等待队列。此时的线程已经万事俱备，就等待CPU从等待队列的调度，为其分配时间片；

  • 运行：线程被成功调度并分配处理器资源，线程就进入了运行阶段。此时自动调用线程对象的run()方法；

  • 堵塞：线程在某些特殊情况下，暂停自己的运行状态，如 I/O操作等，或者调用线程的sleep()、wait()、join()方法等

    都可以使线程进入堵塞阶段；当引起阻塞的原因被消除后，线程就能重新回到就绪阶段，等待CPU调度。

  • 终止：线程有三种方式终止自己，终止后不具有运行能力

    1. run()方法执行完，正常结束线程；

    2. 使用stop()方法强行终止线程，此方法直接终止线程（不推荐， Deprecated(since = “1.2”) ）；

2. 4 多线程常用的操作方法

2. 4. 1 线程的命名和取得

  1. 构造方法传入

    public Thread(Runnable target, String name) { }

  2. 调用setName()方法传入

    public final synchronized void setName(String name) { this.name = name; }

  3. 取得线程名字

    public final String getName() { return name; }

    线程名若不设定则会自动命名 ，使用默认名 "Thread - XXX "

2. 4. 2 线程休眠

public static void sleep(long millis, int nanos) throws InterruptedException { } // 指定睡眠毫秒数，纳秒数

public static native void sleep(long millis) throws InterruptedException; { } // 指定睡眠毫秒数

线程休眠使线程暂停运行，进入堵塞阶段，经过指定毫秒数后，又回到就绪阶段，等待调度；

睡眠中可能会产生中断异常 InterruptedException ，需对其进行异常捕获或处理。

2. 4. 3 线程中断

private volatile boolean interrupted;   // 中断状态位
public void interrupt()     // 使interrupted为true，抛出异常后立即又把设置interrupted为false
public boolean isInterrupted()  { return  interrupted; }    // 测试线程是否已经中断。线程的中断状态不受该方法的影响。
public static boolean interrupted()    // 测试当前线程是否已经中断。线程的中断状态 由该方法清除。

interrupt() 方法使 interrupted 为 true，也就是设置中断位为true，线程会时不时的检测这个中断位，一旦检测 interrupted 为 false，则 抛出interruptedException，中断的结果使堵塞的线程重新回到就绪状态。

interrupt()方法的作用不是终止线程，不会中断一个正在运行的线程。而是改变中断状态，使处于堵塞状态的线程产生interruptedException异常（需提前进行好异常处理），让线程提前结束堵塞状态，所以使线程堵塞的方法（ wait()、join()、sleep() ）都会有throws interruptedException。

Thread.interrupt()方法: 作用是中断线程。将会设置该线程的中断状态位，即设置为true，中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。线程会不时地检测这个中断标示位，以判断线程是否应该被中断（中断标示值是否为true）。它并不像stop方法那样会中断一个正在运行的线程　
interrupt()方法只是改变中断状态，不会中断一个正在运行的线程。需要用户自己去监视线程的状态为并做处理。支持线程中断的方法（也就是线程中断后会抛出interruptedException的方法）就是在监视线程的中断状态，一旦线程的中断状态被置为“中断状态”，就会抛出中断异常。这一方法实际完成的是，给受阻塞的线程发出一个中断信号，这样受阻线程检查到中断标识，就得以退出阻塞的状态。
更确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，此时调用该线程的interrupt()方法，那么该线程将抛出一个 InterruptedException中断异常（该线程必须事先预备好处理此异常），从而提早地终结被阻塞状态。如果线程没有被阻塞，这时调用 interrupt()将不起作用，直到执行到wait(),sleep(),join()时,才马上会抛出 InterruptedException。

2. 4. 4 线程合并

public final void join() throws InterruptedException

调用join()的线程将在所处线程前执行，所在的线程进入堵塞阶段

public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread execute!");
                    sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        thread.join();               // main线程受阻等待thread执行完再执行
        for(int i = 0;i < 10;i++){
            System.out.print(i + " ");
        }
    }
}

2. 4. 5 线程让步

public static native void yield();

yield()做的是让当前运行线程回到就绪状态，给其他线程运行的机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。如果线程数很少，可能会无效果。

2. 4 . 6 线程优先级

线程优先级与线程的调度有关，个人优先级是主观意向，实际被调度的几率还是和性能有关。

 public static final int MIN_PRIORITY = 1;
 public static final int NORM_PRIORITY = 5;         // 主线程默认优先级为5
 public static final int MAX_PRIORITY = 10;

 public final void setPriority(int newPriority)        // 获取优先级
 public final int getPriority()                    // 设置优先级

3. 线程同步和死锁问题

3. 1 同步

同步方法和同步代码块

3. 1线程通讯

wait() 和 notifyAll() 、 notifyAll()

3. 2 守护线程，非守护线程（用户线程）

private boolean daemon = false;   // 默认线程为非守护线程

通过调用 setDaemon() 方法来设置守护线程

 public final void setDaemon(boolean on) {
        checkAccess();
        if (isAlive()) 
            throw new IllegalThreadStateException(); // 线程死亡后调用此方法抛出异常
        }  
        daemon = on;   // 源码通过调用setDaemon()方法来设置 daemon 的值
    }

join() 线程对象调用，当前线程等待其执行完在执行

public class Test {
    public static void main (String[] args)throws Exception {
        thread2();
    }
    public static void thread1(){
        Thread daemonThread = new Thread(()->{
            for(int i = 0;i < 10;i++){
                System.out.println("非守护线程（用户线程）执行");
            }
        });
        daemonThread.setDaemon(true);
        for(int i=0;i<10;i++){
            System.out.println("主线程执行");
        }
        System.out.println(Thread.currentThread().getName() + "执行结束");
    }
    public static void thread2() throws Exception{
        Thread thread1 = new Thread(()->{
            for(int i = 0;i < 10;i++){
                System.out.println("Thread1 execute!");
            }
        });
        thread1.start();
        Thread thread2  = new Thread(()->{
            try {
                thread1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for(int i = 0;i < 100;i++){
                System.out.println("Thread2 execute!");
            }
        });
        thread2.start();
        Thread thread3  = new Thread(()->{
            try {
                thread2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for(int i = 0;i < 100;i++){
                System.out.println("Thread3 execute!");
            }
        });
        thread3.start();
    }
}

4. 锁

synchronized作用在实例方法上锁对象, synchronized作用在静态方法上锁类

synchronized(){}代码块,锁对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VJ69E0UG-1605695535625)(E:\QQFile\1833475904\FileRecv\MobileFile\CSDN_1603966901791.jpg)]

package multieThread;
class A{
    private static int b = 100;
    public static void fun(){      // 静态方法
        synchronized (A.class){    // 锁类
            while(b > 0){
                b--;
                System.out.println(b);
            }
        }
    }
}
public class Test1 implements Runnable {
    private static int a;
    @Override
    public void run() {
        A.fun();
    }
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        new Thread(test1).start();
        new Thread(test1).start();
        new Thread(test1).start();
    }
}

同步方法使用this锁 , 静态同步方法使用当前class文件

Andrew#
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java多线程实验心得体会_JAVA多线程学习心得（一）
weixin_32873435的博客
02-27 2237
最近在github上写了几个关于多线程的练习， 项目地址：https://github.com/jndf/multithreading-pratice需要的朋友可以看看，代码如有错误，请多提出指正意见。下面说一下最近的一些心得。Thread和Runnable两种实现方式。这两种方法都是最基础的实现线程的方法，声明线程对象后，通过调用对象的start()方法，来执行线程内部的run()方法。其中Ru...
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java 多线程学习
hua226的博客
04-13 2万+
Java 多线程 一、实现多线程 1.1 进程 进程：是正在运行的程序 是系统进行资源分配和调用的独立单位 每一个进程都有它自己的内存空间和系统资源 1.2 线程 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程：一个进程如果有多条执行路径，则称为多线程程序 1.3 多线程的实现方式 多线程的实现方案有两种： 继承Thread类 实现Runnable接口 方式1：继承Thread类 定义一个MyThread类继承Thread类 在M
Java多线程学习
weixin_49376454的博客
05-16 1054
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习
Java技术——Java多线程学习
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
09-01 1万+
0.前言 转载请标明出处：http://blog.csdn.net/seu_calvin/article/details/52400927 学习多线程之前需要先了解以下几个概念。 进程：一般指一个程序运行时的实例，每个进程有自己独立的地址空间。一个进程无法直接访问另一个进程的数据。 线程：是CPU调度的最小单元，一个进程可以有很多线程，每条线程可以并行执行不同的任务。并且每个线程有独立的运...
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
java多线程学习（超详细吐血总结）
chenruijia170707的博客
11-11 2万+
声明：原文出处http://www.cnblogs.com/nsw2018/p/5822270.html，本人出于学习，收集干货，不作商业用途！以下原作者为林炳文Evankaka的原创作品。转载出处：http://blog.csdn.net/evankakahttp://blog.csdn.net/evankaka/article/details/44153709#t1  （java线程学习的入门...
编程必备：JAVA多线程详解
拾一二的博客
06-14 7874
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 14万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
JAVA多线程学习心得（一）
去宇宙
04-07 4125
最近在github上写了几个关于多线程的练习， 项目地址：https://github.com/jndf/multithreading-pratice 需要的朋友可以看看，代码如有错误，请多提出指正意见。 下面说一下最近的一些心得。 Thread和Runnable两种实现方式。 这两种方法都是最基础的实现线程的方法，声明线程对象后，通过调用对象的start()方法，来执行线程内...
Java多线程学习总结
09-14
Java多线程是编程中的重要概念，尤其在开发高并发、高性能的应用时不可或缺。本文将深入探讨Java中的线程和进程，以及如何在Java中实现多线程。 首先，理解线程和进程的概念至关重要。线程是操作系统分配CPU时间片...
java多线程学习视频
10-30
Java多线程是一块重要的内容，李兴华讲解的Java是一个很好的资源
Java多线程学习Java多线程学习Java多线程学习Java多线程学习.txt
05-15
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java...
配置Java开发环境
Broken_x的博客
07-10 1564
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 527
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
【Go系列】 Sync并发控制
最新发布
u013379032的博客
07-14 641
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
elk部署springboot
Chihirozy的博客
07-11 386
elk部署springboot。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 281
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
java多线程 学习
04-19
Java多线程是指在Java程序中同时执行多个线程的机制。通过使用多线程，可以实现并发执行，提高程序的效率和响应性。在Java中，可以通过以下几种方式来实现多线程： 1. 继承Thread类：创建一个继承自Thread类的子类...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值