Java中的多线程

已于 2024-03-13 17:58:11 修改
阅读量320 收藏 1
点赞数 1
文章标签： java
于 2022-03-21 16:56:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45759354/article/details/123610473
版权

一、什么是多线程

多线程是指从软硬件上实现多条执行流程的技术。

二、线程的创建方式

2.1 方法一：继承Thread类

1. 定义子类MyThread继承Thread类，重写run()方法

package com.hkd.thread;

public class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出"+ i);
        }
    }
}

2. main中创建MyThread类的对象，调用线程对象的start方法开启线程（启动后还是执行run方法）

package com.hkd.thread;

public class ThreadDemo1 {
    public static void main(String[] args) {
        // new一个新线程对象
        Thread t = new MyThread();
        // 调用start方法启动线程
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出"+ i);
        }
    }
}

疑问：

  1. 为什么不调用run()，而是调用start()开启线程？
    直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。只有调用start方法才是启动一个新的线程执行。
  2. 为什么子线程要放在主线程之前写？
    如果主线程放在子线程之前了，主线程一直是先跑完的，相当于单线程了。

方法一的优缺点：

  1. 优点：编码简单
  2. 缺点：线程类已经继承Thread类，无法继承其他类，不利于扩展

2.2 方法二：实现Runnable接口

1. 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法

package com.hkd.thread;

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行输出"+ i);
        }
    }
}

2. 创建MyRunnable任务对象，把MyRunnable任务对象交给Thread处理；调用线程对象的start方法开启线程。

package com.hkd.thread;

public class ThreadDemo1 {
    public static void main(String[] args) {
        // 创建一个任务对象
        Runnable target = new MyRunnable();
        // 把任务对象交给Thread处理
        Thread t = new Thread(target);
        // 开启线程
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出"+ i);
        }
    }
}

在创建线程的时候，不会立即执行run()，而是等到start()执行的时候，才会开始执行run()。

方式二的优缺点:

  1. 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
  2. 缺点:编程多一层对象包装（任务对象），如果线程有执行结果是不可以直接返回的。

2.3 方法二的另一种写法（匿名内部类）

package com.hkd.thread;

public class ThreadDemo1 {
    public static void main(String[] args) {
	    new Thread(() -> {
	                for (int i = 0; i < 10; i++) {
	                    System.out.println("子线程执行输出"+ i);
	                }
	            }).start();
	        // 把任务对象交给Thread处理
	        Thread t = new Thread(target);

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出"+ i);
        }
    }
}

2.4 方法三：实现Callable接口

1. 定义MyCallable类实现Callable接口，重写call方法，封装要做的事情

package com.hkd.thread;

import java.util.concurrent.Callable;

// 需声明线程任务执行完毕后的结果数据类型
public class MyCallable implements Callable<String> {

    private int n;
    public MyCallable(int n){
        this.n = n;
    }

    // 重写call方法
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return "子线程的执行结果："+ sum;
    }
}

2. 用FutureTask把Callable对象封装成线程任务对象，把这个对象交给Thread处理，调用start方法开启线程，执行任务；线程执行完毕后，通过FutureTask的get方法获取任务执行的结果

package com.hkd.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo1 {
    public static void main(String[] args) {

        // 创建Callable对象
        Callable<String> call1 = new MyCallable(100);
        // 把Callable任务对象封装成FutureTask，它是Runnable对象（实现Runnable接口），可以交给Thread
        // 可以在线程执行完毕之后通过get方法得到线程执行的结果
        FutureTask<String> f1 = new FutureTask<>(call1);
        // 交给线程处理
        Thread t1 = new Thread(f1);
        t1.start();

        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

		// get方法获取任务执行的结果，如果上面代码没有执行完是不执行这里的
        try {
            String rs1 = f1.get();
            System.out.println("线程1结果："+ rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            String rs2 = f2.get();
            System.out.println("线程2结果："+ rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

方法三的优缺点：

  1. 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。可以在线程执行完毕后去获取线程执行的结果。
  2. 缺点:编码复杂一点。

三、线程提供的API

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

package com.hkd.thread.com.hkd.thread2;

public class ThreadMain {
    public static void main(String[] args) throws Exception {
        Thread t1 = new MyThread();
        // 给当前线程命名
        t1.setName("一号");
        t1.start();
        System.out.println(t1.getName());

        Thread t2 = new MyThread();
        t1.setName("二号");
        t2.start();
        System.out.println(t2.getName());

        // 当前正在运行的线程对象
        Thread m = Thread.currentThread();
        System.out.println(m.getName());

        for (int i = 0; i < 5; i++) {
            System.out.println("main线程输出：" + i);
            if(i==3)
                // 让当前线程休眠
                Thread.sleep(3000);
        }
    }
}

package com.hkd.thread.com.hkd.thread2;

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出：" +i);
        }
    }
}

四、线程安全问题

4.1 线程安全问题的原因

  • 多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题
  • 出现安全问题的原因：多线程并发，同时访问共享资源，存在修改共享资源

4.2 解决方法——线程同步

  • 让多个线程实现先后依次访问共享资源，这样就解决了安全问题。
  • 线程同步的核心思想：
    加锁。把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

4.2.1 解决方法一——同步代码块

  • 作用：把出现线程安全问题的核心代码给上锁。
  • 原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行
  • 用synchronized给核心代码上锁
  • 规范上：建议使用共享资源作为锁对象
  • 对于实例方法：建议使用this作为锁对象
  • 对于静态方法：建议使用字节码（类名.class）对象作为锁对象
    public void drawmoney(double money) {
        // 1. 获取谁来取钱
        String name = Thread.currentThread().getName();
        // 同步代码块
        synchronized (this) {
            // 2. 判断账户余额够不够
            if(this.money >= money){
                System.out.println(name + "来取钱成功，吐出" + money);
                this.money -= money;
                System.out.println(name + "取钱后剩余" + this.money);
            } else {
                System.out.println(name + "取钱，余额不足");
            }
        }
    }

4.2.2 同步方法

  • 作用：把出现线程安全问题的核心方法给上锁。
  • 原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。
  • 对于实例方法默认使用this作为锁对象。
  • 对于静态方法默认使用类名.class对象作为锁对象。
//同步方法（锁起来）
    public synchronized void drawmoney(double money) {
        // 1. 获取谁来取钱
        String name = Thread.currentThread().getName();

        // 2. 判断账户余额够不够
        if (this.money >= money) {
            System.out.println(name + "来取钱成功，吐出" + money);
            this.money -= money;
            System.out.println(name + "取钱后剩余" + this.money);
        } else {
            System.out.println(name + "取钱，余额不足");
        }
    }

疑问：

同步代码块和同步方法哪个更好一些？
答：同步代码块锁的范围更小，同步方法锁的范围更大。

4.2.3 Lock锁

可以灵活地上锁和解锁。

public void drawmoney(double money) {
        // 1. 获取谁来取钱
        String name = Thread.currentThread().getName();

        // 上锁
        lock.lock();
        try {
            // 2. 判断账户余额够不够
            if (this.money >= money) {
                System.out.println(name + "来取钱成功，吐出" + money);
                this.money -= money;
                System.out.println(name + "取钱后剩余" + this.money);
            } else {
                System.out.println(name + "取钱，余额不足");
            }
        } finally {
            //解锁
            lock.unlock();
        }
    }

4.3 线程通信

- 什么是线程通信、如何实现?

  • 所谓线程通信就是线程间相互发送数据。

- 线程通信常见形式

  • 通过共享一个数据的方式实现。
  • 根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

- 线程通信实际应用模型

  • 生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。
  • 一般要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。

4.4 线程通信的三个方法

在这里插入图片描述
上述方法应该用当前同步锁对象调用

五、线程池

5.1 什么是线程池

线程池就是一个可以复用线程的技术。

  • 不使用线程池的问题

    如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

5.2 谁创建线程池

JDK 5.0起提供了代表线程池的接口：ExecutorService

5.3 如何得到线程对象

使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象，
ThreadPoolExecutor构造器的参数说明在这里插入图片描述

5.4 线程池面试题

1. 临时线程是什么时候创建的？

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

2. 什么时候开始拒绝任务？

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

5.5 线程池处理Runnable任务

使用ExecutorService的方法：void execute(Runnable target)

package com.hkd.threadpool;

import java.util.concurrent.*;

/**
 * 自定义线程池对象
 */
public class threadpooldemo {
    public static void main(String[] args) {
        /**
         * public ThreadPoolExecutor(int corePoolSize,
         *                               int maximumPoolSize,
         *                               long keepAliveTime,
         *                               TimeUnit unit,
         *                               BlockingQueue<Runnable> workQueue,
         *                               ThreadFactory threadFactory)
         */
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 6, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        // 给任务线程池，Runnable任务
        Runnable target = new MyRunnable();
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
    }
}

5.6 线程池处理Callable任务

使用ExecutorService的方法：Future<T> submit(Callable<T> command)

package com.hkd.threadpool;

import com.hkd.thread.MyCallable;

import java.util.concurrent.*;

/**
 * 自定义线程池对象
 */
public class threadpooldemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 6, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        /**
         * 处理Callable任务
         */
        // 提交Callable任务，返回Future任务对象
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

在线程池执行submit()方法的时候，假设第一个线程执行的时候，第二个线程是否会执行是看线程调度器决定的，如果线程池中有足够的空闲线程，那么第二个线程任务可以立马执行，但如果线程池中的所有线程都在执行其他任务，则第二个线程将会等待，直到有空闲线程可以使用。

5.7 新任务拒绝策略

在这里插入图片描述

无奇不有 不置可否
关注
多线程---狂神说java学习笔记
rzz65452064的博客
02-26 512
多线程详解 狂胜说java–多线程，bilibili视频地址 Java. Thread 目录 线程简介 线程实现（重点） 静态代理模式 Lambde表达式 线程状态 线程同步（重点） 线程通信问题 高级主题 一、线程简介 任务，进程，线程，多线程 任务 类似于干的事情 线程Thread 类似于道路。 普通方法调用：只有主线程一条执行路径。 （主程序→子程序→主程序） 多线程：多条执行路径，主线程和子线程并行交替执行。 （主程序→子程序） （ →主程序） 进程Process 操作系统中运行的程序就是
java中多线程统计时间_Java多线程下统计多个线程的运行时间
weixin_34321609的博客
02-25 1697
今天复习了一下java中Synchronized等关于多线程的问题。Synchronized是Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。Java的每个对象都有一个内部锁，如果一个方法用synchronized关键字声明，那么对象的锁将保护整个方法。要调用该方法必须获得内部的对象锁。一、当两个并发线程访问同一个对象object中的...
Java总结篇系列：Java多线程（一）
weixin_34228662的博客
06-30 414
多线程作为Java中很重要的一个知识点，在此还是有必要总结一下的。 一.线程的生命周期及五种基本状态 关于Java中线程的生命周期，首先看一下下面这张较为经典的图： 上图中基本上囊括了Java中多线程各重要知识点。掌握了上图中的各知识点，Java中的多线程也就基本上掌握了。主要包括： Java线程具有五中基本状态 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thre...
多线程（java)
最新发布
m0_63272315的博客
08-28 1168
一个线程就是一个 "执行流". 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 "同时" 执行 着多份代码.举个生活中的例子：想象一下你去一家咖啡店点咖啡的情景。在这个例子中，我们可以将这家咖啡店看作是一个程序，而店内的工作人员则可以视为线程。假设这家咖啡店提供两种服务：一种是现场制作咖啡，另一种是准备外卖订单。为了提高效率，咖啡店安排了两个工作人员分别负责这两项工作。：一位工作人员专门负责为现场顾客制作咖啡。当顾客下单后，这位工作人员就开始准备咖啡，并且在完成后交给顾客。
java多线程
m0_46702681的博客
06-19 2205
javajava。
Java 中的多线程
weixin_33755649的博客
08-23 118
线程操作系统能够执行调度的最小单位。我们在面对一些高并发场景或耗时任务的时候，通常都会采用异步线程的方式，在java中，使用线程的方式本身就很多，除了原生的Thread可以包装Runnable，还有Executor线程池可以包装Runnable、Callable、Futrue接口，也可以用FutrueTask做适配。不同的线程创建方式对应不同的应用场景，而对于一般的后台系统或者应用程序而言，使用合...
java向多线程中传递参数的三种方法详细介绍
09-05
以下将详细介绍三种向Java多线程传递参数的方法。 1. **通过构造方法传递数据** 当创建Thread类或其子类的实例时，可以利用构造方法来传递数据。这些数据通常存储为类的成员变量，在`run()`方法中使用。例如： ``...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java 高并发多线程编程系列案例代码
01-02
Java 高并发多线程编程系列案例代码 & 教程 & 面试题集锦! !! 包括但不限于线程安全性, atomic包下相关类、CAS原理、Unsafe类、synchronized关键字等的使用及注意事项,
详解Java多线程处理List数据
08-26
Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List数据的知识点。 一、什么是...
JAVA中多线程
Calm的博客
12-24 2226
我们可以先来看一幅图，多线程就算围绕这幅图展开的。 1. 进程与线程的概念 进程：操作系统中一个程序的执行周期。 线程：一个线程同时执行多个任务。通常来讲，每一个任务就称为一个线程。 进程与线程比较 与进程相比，线程更加“轻量级”，创建、撤销一个线程比启动、撤销一个进程开销要小的多。一个进程中的所有线程共享此进程的所有资源。 没有进程就没有线程，进程一旦终止，其内的线程也将不复存在。 进程是操...
JAVA之多线程
maxu0808的博客
03-18 4573
一、什么是多线程 1. 线程与进程、并行与并发 进程：每个进程拥有自己的一整套变量。一个进程可以包含多个线程。 线程：线程属于进程，多个线程会存在共享数据的情况发生，也就是多个线程会共享同一块内存区域。 一个例子：打开word是一个进程，打开qq音乐又是另外一个进程，两进程之间不会互相影响（都有自己的一块内存区域）。但比如在qq音乐里一遍听歌，一遍又浏览排行榜，那就是在qq音乐这个进程里又有两个线程，它们之间会存在共享内存的情况。 并发：多线程就是并发的例子，一块CPU调度时会分为好多个时间片，每
Java 多线程
千樽醉的博客
12-14 117
进程与线程 进程是程序的一次动态执行过程，它需要经历从代码加载，代码执行到执行完毕的一个完整的过程，这个过程也是进程本身从产生，发展到最终消亡的过程。多进程操作系统能同时达运行多个进程（程序），由于 CPU 具备分时机制，所以每个进程都能循环获得自己的CPU 时间片。由于 CPU 执行速度非常快，使得所有程序好像是在同时运行一样。 多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的执行单位，线程是进程的基础之上进行进一步的划分。所谓多线程是指一个进程在执行过程
Java 多线程
lercent的博客
03-31 216
一、Java多线程 1. 进程和线程 进程和线程都是一个时间段的描述。 进程：进程是正在运行的程序的实例，是系统资源分配的最小单位。 线程：线程可以理解为进程中独立运行的子任务，是CPU调度的最小单位。 2. 使用多线程 实现多线程编程的方式主要有两种，一种是继承 Thread 类，另一种是实现 Runnable 接口。 Runnable接口： 定义： public interface Runnable { public abstract void run(); } Thread类： 构造函数：
JAVA多线程
weixin_45812603的博客
07-27 347
/线程的三种启动方式 public static void main(String [ ] args) {//1.方式1 继承Thread启动线程 Mythread mythread = new Mythread();//2.方式2 实现 Runable接口启动 Mytask mytask = new Mytask();//3.方式3 匿名内部类启动 与方式2本质上相同只是简洁写法 但是可读性差 new Thread(new Runnable() {i < 10;i ++) {
Java中多线程的使用
08-07
Java 中的多线程可以通过创建 Thread 类的实例来实现。具体步骤如下： 1. 创建一个实现 Runnable 接口的类，该类实现 run() 方法。 ```java public class MyRunnable implements Runnable { public void run() { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值