JavaEE - 多线程

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量194 收藏
点赞数
分类专栏： JavaEE 文章标签： 多线程 java javaee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43320309/article/details/118940433
版权

1. 进程

进程是系统进行资源分配和调用的独立单元，每一个进程都有它的独立内存空间和系统资源。

一个进程包括由操作系统分配的内存空间，包含一个或多个线程。

单进程和多进程操作系统的区别

  • 单进程操作系统：dos（一瞬间只能执行一个任务）

  • 多进程单用户操作系统：Windows（一瞬间只能执行多个任务）

  • 多进程多用户操作系统：Linux

2. 线程

一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

线程和进程的关系

  • 线程是进程里面的一条执行路径。同一个进程里的每条线程共享进程里面的内存空间和系统资源

  • 一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

  • 进程里只有一条线程的情况下，这条线程就叫做主线程

  • 进程里有多条线程的情况下，只有一条线程叫做主线程

  • 线程是在进程里的，他们是包含关系

3. 线程的生命周期

线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

生命周期

  • 新建状态:

    使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。保持这个状态直到程序 start() 这个线程。

  • 就绪状态:

    新建线程对象后，调用该线程的start()方法之后，该线程进入就绪状态。就绪状态的线程将进入线程队列排队，等待JVM里线程调度器的调度。

  • 运行状态:

    当就绪状态的线程被调用并获得 CPU 资源时，线程就进入了运行状态。此时，自动调用该线程对象的run()方法。run()方法定义了该线程的操作和功能。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

  • 阻塞状态:

    如果一个正在执行的线程调用了sleep()、wait()等方法，将让出CPU并暂时中止自己的执行，该线程进入阻塞状态。阻塞时，线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以重新进入就绪状态。可以分为三种：

    • 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
    • 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
    • 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

  • 死亡状态:

    一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到死亡状态。处于死亡状态的线程不具有继续运行的能力。

4. 创建线程

Java 提供了三种创建线程的方法

  • 通过继承 Thread 类本身；
  • 通过实现 Runnable 接口；
  • 通过 Callable 和 Future 创建线程。

4.1 实现Runnable接口 - 任务类

创建Task类，实现Runnable接口中的run方法

//任务类    1.实现Runnable接口 ，作为线程的实现类
class Task implements Runnable{
	//当前线程抢到cpu资源后，就会执行run方法
	@Override // 2.重写run()方法 作为线程的操作主体 
	public void run() {
		System.out.println("任务类线程抢到资源了");
	}
}
public class Test {
	public static void main(String[] args) {
        //4.创建线程对象           3.创建实现类对象
        Thread thread = new Thread(new Task());
        //启动线程：该线程抢到CPU资源后，才会运行run方法
        thread.start();// 5.调用start()方法 启动线程 
	}
}

演示：多线程抢夺系统资源

//实现Runnable接口
class MyThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            //获取当前线程的名称
            System.out.println(Thread.currentThread().getName() + "运行, i=" + i);
        }
    }
}

public class ThreadDemo {
    public static void main(String args[]) {
        MyThread my = new MyThread();  //定义Runnable子类对象
        //系统自动设置线程名称
        new Thread(my).start();
        //手动设置线程名称
        new Thread(my, "线程A").start();
    }
}
//Thread-0运行, i=0
//线程A运行, i=0
//Thread-0运行, i=1
//线程A运行, i=1
//Thread-0运行, i=2
//线程A运行, i=2

两个线程对象是交错运行的，哪个线程对象抢到了 CPU 资源，哪个线程就可以运行，所以程序每次的运行结果是不一样的，在线程启动虽然调用的是 start() 方法，但实际上调用的却是 run() 方法定义的主体。

4.2 继承Thread类 - 线程类

创建MyThread类，继承Thread类，重写run方法（run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。）

//线程类       1.继承Thread类
class MyThread extends Thread{
	//当前线程抢到cpu资源后，就会自动执行run方法
	@Override // 2.重写run()方法
	public void run() {
		System.out.println("线程类线程抢到资源了");
	}
}
public class Test {
	public static void main(String[] args) {	
		// 3.创建子类线程对象
		MyThread thread = new MyThread();
		//启动线程
		thread.start();// 4.调用start()方法
	}
}

Thread 类和 Runnable 接口

public class Thread extends Object implements Runnable

Thread 类也是 Runnable 接口的子类，但在Thread类中并没有完全实现 Runnable 接口中的 run() 方法

//下面是 Thread 类的部分源码
Private Runnable target；
public Thread(Runnable target,String name){
    init(null,target,name,0);
}
...
public void run(){
    if(target!=null){
        target.run();
    }
}

从源码中可以发现，在 Thread 类中的 run() 方法调用的是 Runnable 接口中的 run() 方法，也就是说此方法是由 Runnable 子类完成的，所以如果要通过继承 Thread 类实现多线程，则必须覆写 run()

如果一个类继承 Thread类，则不适合于多个线程共享资源，而实现了 Runnable 接口，就可以方便的实现资源的共享。

4.3 Callable 和 Future 创建线程

  1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值 。

  2. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

  3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

  4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

public class CallableTest implements Callable<Integer> {
    public static void main(String[] args) {
        CallableTest callableTest = new CallableTest();
        //创建一个FutureTask ，它将在运行时执行给定的Callable
        FutureTask<Integer> futureTask = new FutureTask<>(callableTest);
        //主线程的名称：main
        System.out.println("主线程的名称：" + Thread.currentThread().getName());
        //Thread(Runnable target, String name)
        new Thread(futureTask, "有返回值的线程").start();
        try {
            //子线程的返回值：10
            System.out.println("子线程的返回值：" + futureTask.get());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    @Override
    public Integer call() throws Exception {
        int i = 10;
        //子线程的名称：有返回值的线程
        System.out.println("子线程的名称：" + Thread.currentThread().getName());
        return i;
    }
}

4.4 创建线程的三种方式的对比

  • 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
  • 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

5. Thread 方法

列出被Thread对象调用 的一些重要方法：

方法描述
void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
void run()如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
void setName(String name)改变线程名称，使之与参数 name 相同。
void setPriority(int priority)更改线程的优先级。
void setDaemon(boolean on)将该线程标记为守护线程或用户线程。
void join(long millisec)等待该线程终止，时间最长为 millis 毫秒。（让一个线程强制运行，线程强制运行期间，其他线程必须等待此线程终止之后才可以继续执行）
void interrupt()中断线程。
final boolean isAlive()测试线程是否处于活动状态。
public class Task implements Runnable{
   @Override
   public void run() {
      System.out.println("run方法被调用了");
   }
}

public class Test {
    public static void main(String[] args) {
        //创建子线程
        Thread thread = new Thread(new Task());
        //更改线程的优先级
        thread.setPriority(Thread.MAX_PRIORITY);//10
        //参数为true时 将此线程标记为守护线程
        thread.setDaemon(false);
        //更改线程的名称为：Hello线程
        thread.setName("Hello线程");
        //启动线程
        thread.start();
        //中断此线程
        thread.interrupt();
        //测试此线程是否存活
        System.out.println(thread.isAlive());
        try {
            //等待这个线程死亡,再向下执行
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

列出Thread类的静态方法 ：

方法描述
void yield()放弃，向调度程序提示当前线程放弃其当前对处理器的使用。回到就绪状态，竞争下一次时间片。
void sleep(long millisec)在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
boolean holdsLock(Object x)当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。
Thread currentThread()返回对当前正在执行的线程对象的引用。
void dumpStack()将当前线程的堆栈跟踪打印至标准错误流。

1. 线程的休眠

Thread.sleep(毫秒);

此方法为静态方法，写在哪个线程中，哪个线程就休眠

需求：编写一个抽取学生回答问题的程序，要求倒数三秒后输出被抽中的学生姓名

public static void main(String[] args) throws InterruptedException {
    //创建随机数对象
    Random ran = new Random();
    String[] names = {"中野三玖", "志田黑羽", "樱泽墨", "莱卡"};
    //返回一个伪随机、均匀分布的int值，介于 0（含）和指定值（不含）之间
    int index = ran.nextInt(names.length);
    //3秒倒计时
    for (int i = 3; i > 0; i--) {
        System.out.println(i);
        //休眠1000毫秒
        Thread.sleep(1000);
    }
    System.out.println(names[index]);
}
//3
//2
//1
//樱泽墨

2. 线程的礼让

Thread.yield();

此方法为静态方法，此方法写在哪个线程中，哪个线程就礼让

将一个线程的操作暂时让给其他线程执行（指当前线程退出CPU资源，并转到就绪状态，接着再抢）

需求：创建两个线程A,B，分别各打印1-100的数字，其中B一个线程，每打印一次，就礼让一次

class A extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println("A:" + i);
        }
    }
}

class B extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println("B:" + i);
            //礼让：让当前线程退出CPU资源
            Thread.yield();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        a.start();
        b.start();
    }
}

3. 线程的合并

t.join();

在线程操作中，可以使用 join() 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行

需求：主线程和子线程各打印15次，从1开始每次增加1，当主线程打印到5之后，让子线程先打印完再打印主线程

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 15; i++) {
            System.out.println("子线程：" + i);
        }
    }
}

public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        //创建子线程
        MyThread t = new MyThread();
        t.start();
        for (int i = 1; i <= 15; i++) {
            System.out.println("主线程：" + i);
            if (i == 5) {
                //将t线程加入到当前线程强制运行
                t.join();
            }
        }
    }
}

4. 线程的中断

t.interrupt();

当一个线程运行时，另外一个线程可以直接通过interrupt()方法中断其运行状态。

需求：子线程循环打印人名，主线程0.1秒后中断子线程打印

class MyThread extends Thread {
    @Override
    public void run() {
        //获取当前线程状态  true - 线程终止  false - 线程存活
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("樱泽墨");
        }
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread t = new MyThread();
        t.start();
        Thread.sleep(100);
        t.interrupt();//改变线程状态
    }
}

5. 守护线程

t.setDaemon(true);

守护线程 默默守护着前台线程，当所有的前台线程都消亡后，守护线程会自动消亡

注意：垃圾回收器就是守护线程

class MyThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("守护线程，正在默默守护着前台线程");
            try {
                Thread.sleep(1001);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread t = new MyThread();
        //将t线程设置为守护线程
        t.setDaemon(true);
        t.start();
        for (int i = 1; i <= 2; i++) {
            System.out.println("主线程 ：" + i);
            Thread.sleep(1000);
        }
    }
}
//主线程 ：1
//守护线程，正在默默守护着前台线程
//主线程 ：2
//守护线程，正在默默守护着前台线程
// 
//进程已结束，退出代码为 0

6. 线程局部变量（实现线程范围内的共享变量）

未完待续。。。。。

7. 多线程的使用

  • 有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。
  • 通过对多线程的使用，可以编写出非常高效的程序。不过请注意，如果创建太多的线程，程序执行的效率实际上是降低了，而不是提升了。
  • 请记住，上下文的切换开销也很重要，如果创建了太多的线程，CPU 花费在上下文的切换的时间将多于执行程序的时间！

8. 线程的优先级别

在 Java 的线程操作中，所有的线程在运行前都会保持在就绪状态，那么此时，哪个线程的优先级高，哪个线程就 有可能 会先被执行。

class MyThread implements Runnable { // 实现Runnable接口
    @Override
    public void run() {  //重写run()方法
        //取得当前线程的名字
        System.out.println(Thread.currentThread().getName() + "运行");
    }
}

public class ThreadPriorityDemo {
    public static void main(String args[]) {
        // 实例化线程对象
        Thread t1 = new Thread(new MyThread(), "线程A");
        Thread t2 = new Thread(new MyThread(), "线程B");
        Thread t3 = new Thread(new MyThread(), "线程C");
        t1.setPriority(Thread.MAX_PRIORITY); //优先级最高 10
        t2.setPriority(Thread.NORM_PRIORITY); //优先级中等 5
        t3.setPriority(Thread.MIN_PRIORITY); //优先级最低 1
        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}
//线程B运行
//线程A运行
//线程C运行

从程序的运行结果中可以观察到，线程将根据其优先级的大小来决定哪个线程会先运行，但是注意并非优先级越高就一定会先执行，哪个线程先执行将由 CPU 的调度决定。

Miku-Y
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java在线源码-JavaEE-Unit02:JavaEE在线课程使用的源码->单元2-多线程
06-01
java在线源码JavaEE在线...JavaEE在线课程->单元2-多线程中使用的源代码。 这些类代表了 Java 中多线程的使用，如 Dimik Computing 举办的在线课程中所演示的。 随意分叉并自己尝试。 @author Mushfekur Ra​​hman ()
笔记16-JAVAEE之多线程进阶
12-17
笔记16-JAVAEE之多线程进阶
java多线程模型_1、java线程模型
weixin_28928727的博客
02-21 398
要了解多线程，先需要把java线程模型搞清楚，否则有时候很难理清楚一个问题。硬件多线程：物理机硬件的并发问题跟jvm中的情况有不少相似之处，物理机的并发处理方案对于虚拟机也有相当大的参考意义。在买电脑或者自己diy的时候经常看到商家的介绍，什么“4核8线程”，“8核16线程”；这里“核”是指cpu的核心数，所谓“4核8线程”就是将2个cpu放置到一个封装内，比如i7-7700k是4个cpu8线程，...
JavaEE-多线程初阶2
qq_63983125的博客
12-13 901
JavaEE-多线程初阶2
5-12JavaEE-多线程
2203_75335776的博客
05-12 108
JavaEE-多线程-CAS
Gremmie的博客
08-12 268
本篇文章详细介绍了Java中CAS的机制和操作
5-26-JavaEE-多线程死锁
2203_75335776的博客
05-26 104
0506-JavaEE-多线程前后台线程
2203_75335776的博客
05-06 83
5-13JavaEE-多线程安全问题
2203_75335776的博客
05-13 107
JavaEE-多线程进阶
qq_63983125的博客
01-24 1953
锁策略，CAS，synchronized 原理，JUC，多线程环境使用哈希表
5-29-JavaEE-多线程单例设计模式
2203_75335776的博客
05-29 93
JavaEE - 多线程(初阶)
旧时言的博客
03-22 910
多线程-初阶 本节目标 认识多线程 掌握多线程程序的编写 掌握多线程的状态 掌握什么是线程不安全及解决思路 掌握 synchronized、volatile 关键字 1. 认识线程（Thread） 1.1 概念 线程是什么 还是回到我们之前的银行的例子中。之前我们主要描述的是个人业务，即一个人完全处理自己的 业务。我们进一步设想如下场景： 一家公司要去银行办理业务，既要进行财务转账，又要进行福利发放，还得进行缴社保。 如果只有张三一个会计就会忙不过来，耗费的时间特别长。为了让业务更快的办理好，张三又
笔记14-JAVAEE之多线程初阶
12-16
1
疯狂的java讲义源码-JavaEE-Study-Notes:用于记录JavaEE学习过程中的笔记
06-06
疯狂的java讲义 源码 JavaEE-Study-Notes （JavaEE 学习笔记） 用于记录 JavaEE 学习过程中的笔记 知识点预览（个人学习要求） ...多线程编程、NIO、反射、序列化、JVM 调优； 1.2 FrontEnd 前端部分： HTML 4.01、CSS
JavaEE学习[JavaSE-06多线程.rar]
03-29
JavaSE-06多线程 JavaSE-06多线程 JavaSE-06多线程 JavaSE-06多线程
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 890
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 895
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1206
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 493
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
javaEE javaSE
02-03
Java SE包含了Java语言的核心库和虚拟机，提供了基本的功能和特性，如面向对象编程、异常处理、多线程、输入输出等。 Java EE（Java Platform, Enterprise Edition）是Java平台的企业版，它是在Java SE的基础上构建...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值