JAVA中的多线程操作详细剖析

于 2024-09-28 10:08:36 发布
阅读量428 收藏 7
点赞数 5
CC 4.0 BY-SA版权
文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_87288783/article/details/142611598

  1. 线程的安全问题与几种机制

  2. 线程之间的通信问题解决方案

二，线程的创建

多线程的创建方式，比较常规的说法是两种方式：1. 继承Thread类 2. 实现Runnable接口。

但是严格来说，有四种：3. 实现Callable接口。4. 线程池

2.1 继承Thread类

步骤：

  1. 创建一个 继承于Thread的子类

  2. 重写Thread类的 run方法 。（将此线程执行的操作声明在run方法中）

  3. 创建Thread类的子类对象

  4. 通过此对象调用**start()**方法

实例代码：

public static void main(String[] args) throws InterruptedException {

// 3. 创建Thread类的子类对象

MyThread t1 = new MyThread();

// 4. 通过此对象调用start()方法 : 1 .导致此线程开始执行 2.Java虚拟机调用此线程的run方法。

t1.start();

// t1.run (只是做了一个创建对象，然后调用对象中的方法操作，等调用的方法执行结束之后，才会执行下面的代码，

// 不会启动一个新的线程)

// 问题1： 我们不能通过直接调用run方法的方式直接调用

// t1.start();

// 问题2： 在启动一个线程，遍历100以内的偶数。

// 再启动一个线程，不可以让已经start()的线程在去调用start()执行，否则会报 IllegalThreadStateException

// 需要重新创建一个对象来调用start()方法

MyThread t2 = new MyThread();

t2.start();

// 如下的操作仍然是在main线程中执行的

for (int i = 0; i < 100; i++) {

if(i % 2 == 0){

System.out.println(Thread.currentThread().getName() + " main== " + i);

}

}

}

}

// 1. 创建一个继承于Thread的子类。

class MyThread extends Thread{

// 2. 重写Thread类的run方法。

@Override

public void run() {

for (int i = 0; i < 100; i++) {

if(i % 2 == 0){

System.out.println(Thread.currentThread().getName()+ " ========= ======" + i);

}

}

}

2.2 实现Runnable接口

步骤：

  1. 创建一个是实现了Runnable接口的一个类。

  2. 实现类去实现Runnable接口中的抽象方法：run()

  3. 创建实现类的对象

  4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。

  5. 通过Thread类的对象调用start()方法

代码：

/ 1. 创建一个实现了Runnable接口的一个类。

class MThread implements Runnable {

// 2. 实现类去实现Runnable中的抽象方法：run()

@Override

public void run() {

for (int i = 0; i < 100; i++) {

if (i % 2 == 0) {

System.out.println(Thread.currentThread().getName() + " === " + i);

}

}

}

}

public class A_03ThreadTest {

public static void main(String[] args) {

// 3. 创建实现类的对象

MThread mThread = new MThread();

// 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。

Thread t1 = new Thread(mThread);

// 5. 通过Thread类的对象调用start(); 作用： 1. 启动线程

// 2.调用当前线程的run()方法 — > 调用了Runnable类型中target的run()方法

t1.start();

// 在创建一个线程

Thread t2 = new Thread(mThread);

t2.start();

}

}

除了以上有通过实现Runnable接口和继承Thread类的方式来创建线程之外，还有两种方法是JDK5新增的两种方法来创建线程。

2.3 实现callable接口

如何理解callable接口的方式创建线程的方式比实现Runnable接口创建线程的方式要强大？

  1. call() 方法是可以有返回值的。

  2. call() 可以抛出异常，被外面的操作捕获。

  3. callable() 是支持泛型的。

代码实例：

// 1.创建一个实现callable的实现类

class NumThread implements Callable{

// 2. 实现call方法，将此线程需要执行的操作声明在call方法中

@Override

public Object call() throws Exception {

int sum = 0;

for (int i = 0; i <= 100; i++) {

if (i % 2 == 0) {

System.out.println(i);

sum += i;

}

}

return sum;

}

}

public class ThreadNew {

public static void main(String[] args) throws ExecutionException, InterruptedException {

// 3. 创建callable接口实现类的对象

NumThread t = new NumThread();

// 4. 将此callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象

FutureTask futureTask = new FutureTask(t);

// 5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法

new Thread(futureTask).start();

// 6. 获取callable中call方法中的返回值

// get 方法的返回值，就为futuretask构造器参数callable实现类重写的call方法的返回值

int sum = (Integer)futureTask.get();

System.out.println(“总和为” + sum);

}

}

2.4 线程池

好处：

  1. 提高相应速度（减少了创建新线程的时间）

  2. 减低资源消耗（重复利用线程池中线程，不需要每次创建）

  3. 便于线程管理

代码示例：

class NumberThread implements Runnable{

@Override

public void run() {

for (int i = 0; i <= 100; i++) {

if (i % 2 == 0) {

System.out.println(Thread.currentThread().getName() + " ::" + i);

}

}

}

}

class NumberThread1 implements Runnable{

@Override

public void run() {

for (int i = 0; i <= 100; i++) {

if (i % 2 == 0) {

System.out.println(Thread.currentThread().getName() + " ::" + i);

}

}

}

}

public class ThreadPool {

public static void main(String[] args) {

// 1.提供指定数量的线程池

ThreadPoolExecutor service = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);

// 设置线程池属性

service.setCorePoolSize(100);

// service.setKeepAliveTime(1000);

// 2. 执行执行线程的操作，需要提供Runnable接口或者是Callable接口实现类的对象

service.execute(new NumberThread()); // 适合使用runnable

service.execute(new NumberThread1()); // 适合使用runnable

// service.submit(); // 适合使用与callable

// 3.关闭连接池

service.shutdown();

}

}

三，线程安全问题

在进行买票问题的分析上，发现了有可能票数会出现不一致的情况，所以需要一定的安全机制来避免这种情况。

出现原因：某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。

如何解决：

当一个线程在操作ticket的时候， 其他线程不能参与进来，直到当前线程操作完毕之后，其他线程才可以操作ticket，即是是当前线程出现了堵塞，情况也不能改变。

在java中主要通过同步机制来解决线程的安全问题：

实现同步机制有以下几种方式：

3.1 同步代码块

【语法】

synchronized(同步监视器){

// 需要被同步的代码

}

说明分析：

  1. 操作共享数据的代码，即为需要被同步的代码。（不能包含多了，有可能会出错），也不能包含少。

  2. 共享数据：多个线程共同操作的变量。

  3. 同步监视器：俗称“锁”。任何一个对象，都可以充当锁。

要求：多个线程必须公用公用一把锁。(调用的时候，传入的是同一个对象)。`

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器

一定是只是创建了一个Runnable接口的对象传入到Thread中的构造方法中，才能保证是同一个对象

在实现Runnable接口的实现类中使用同步代码块解决安全机制：

class Window1 implements Runnable {

private int ticket = 100;

Object lock = new Object();

@Override

public void run() {

while (true) {

// 由于只是new了一个对象，所以，可以使用this关键字来进行代替 此时的this代表的就是window1的对象

synchronized(lock){

if (ticket > 0) {

// 将程序进行缓慢执行0.1秒

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + “：买票， 票号是” + ticket);

ticket–;

} else {

break;

}

}

}

}

}

// 【实现的方式解决线程安全问题】

public class C_01WindowTest1 {

public static void main(String[] args) {

// 由于只是new了一个window的对象，所以Window1类中多个线程都是共享一个lock对象

Window1 w = new Window1();

// 在构造方法中传入实现了runnable接口的类

Thread t1 = new Thread(w);

Thread t2 = new Thread(w);

Thread t3 = new Thread(w);

// 命名操作

t1.setName(“窗口一”);

t2.setName(“窗口二”);

t3.setName(“窗口三”);

// start()开启线程

t1.start();

t2.start();

t3.start();

}

}

需要注意的是：由于实现了Runnable的这个类只是new了一个对象，所以成员变量 Object lock = new Object(); 的对象所有的线程属于是同一个，所以可以达到同步的目的。

如果是 继承Thread的方式实现多线程的方式，需要注意的是需要把锁的对象声明成static，才能使所有的线程都是共享一个lock的变量 。

class Window2 extends Thread {

// 出现线程安全问题

private static int ticket = 100;

// private Object lock = new Object(); 由于同步代码块中的锁不是同一个，所以出现了没有解决同步安全的现象，只要把所有的锁对象换成

// 同一个，那么就可以解决同步的问题，解决方案是，让他们共享同一个对象

private static Object lock = new Object(); // 解决了线程安全的问题

@Override

public void run() {

while (true) {

// 不能使用this关键字作为同步锁 this代表着 t1 , t2, t3三个对象

// synchronized(Window2.class){ 但是可以他们是公用一个类对象，所以，通用一个类对象来进行。类只会加载一次。

synchronized(lock){

if (ticket > 0) {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(getName() + ":买票， 票号是： " + ticket);

ticket–;

}else{

break;

}

}

}

}

}

public class C_02WindowTest2 {

public static void main(String[] args) {

// 创建三个对象

Window2 w1 = new Window2();

Window2 w2 = new Window2();

Window2 w3 = new Window2();

// 命名

w1.setName(“窗口一”);

w2.setName(“窗口二”);

w3.setName(“窗口三”);

// 启动线程

w1.start();

w2.start();

w3.start();

}

}

需要注意的是，锁一定要是同一个。

3.2 同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨考虑将此方法声明为同步的。

【使用实现Runnable接口的方式解决线程安全问题】

public class ThreadTest04 {

public static void main(String[] args) {

Window target = new Window();

// 创建线程Thread

Thread t1 = new Thread(target);

Thread t2 = new Thread(target);

Thread t3 = new Thread(target);

t1.setName(“window - one”);

t2.setName(“window - two”);

t3.setName(“window - three”);

t1.start();

t2.start();

t3.start();

}

}

class Window implements Runnable{

// 总的票数 所有的实例对象只有一个

private static int ticket = 100;

@Override

public void run() {

while (true) {

if (show()) break;

}

}

// 使用关键字synchronized来将show方法作为一个同步方法来解决同步问题

private synchronized boolean show() {

if (ticket > 0) {

System.out.println(Thread.currentThread().getName() + “买票，买票的票号是” + ticket);

ticket --;

} else{

return true;

}

return false;

}

}

原理分析： 由于此时的this，在Runnable只是创建了一个对象，所以，this对象可以为多个线程公用同一把锁。同步方法默认是使用当前对象的this作为同步的锁。

如果是使用继承Thread类的方法解决线程安全问题的写法又是会有些不同。

【使用继承Thread类方法的方式解决线程安全问题】

public class ThreadTest05 {

public static void main(String[] args) {

// 创建线程

Window2 t1 = new Window2();

Window2 t2 = new Window2();

Window2 t3 = new Window2();

// 设置名字

t1.setName(“window-one”);

t2.setName(“window-two”);

t3.setName(“window-three”);

// 启动多个线程

t1.start();

t2.start();

t3.start();

}

}

class Window2 extends Thread{

private static int ticket = 100;

private static Object lock = new Object();

@Override

public void run() {

while (true) {

if (show()) break;

}

}

// 由于此时的调用当前同步方法的对象不是同一个，所以this指代的也不是同一个，所以进行同步方法的时候，需要加上一个static,保证锁是同一把锁

private static synchronized boolean show() {

if (ticket > 0) {

System.out.println(Thread.currentThread().getName() + “买票，买票的票号是” + ticket);

ticket --;

} else{

return true;

}

return false;

}

}

注意：此时需要注意的是，在同步方法中，由于同步方法默认使用的是调用当前方法的this作为多个线程的同步监视器，所以，如果不声明成静态的方法，则this指示的是不同的对象，所以，需要声明程静态方法。

3.3 加锁实现同步

3.3.1ReentrantLock 锁

一种新的实现线程之间同步的方式：

  1. 创建一个ReentrantLock锁

ReentrantLock lock = new ReentrantLock(true);

2.在需要同步的关键地方加锁

lock.lock();

3.线程同步代码结束之后需要进行解锁操作。

lock.unlock();

详细请看：

synchronized和锁(ReentrantLock) 区别_小风筝-优快云博客 区别_小风筝-优快云博客")

四. 线程通信问题

设计到三个方法

注意事项：

2401_87288783
关注
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
Java多线程操作<二>
FLY_THINK2012的博客
07-24 114
同步段代码演示(关键代码段),wait(),notify()方法只能在snychronized标示的代码段和方法中使用,并且需要异常处理. /*** */ /*** @author Administrator**/public class TicketSystem { /** * @param args */public static void main(Stri...
Java多线程操作<一>
FLY_THINK2012的博客
07-24 111
Example <一>: /*** */ /*** @author Administrator**/public class MultiThread { /** * @param args */public static void main(String[] args) {// TODO Auto-generated method stubMy...
Java多线程操作
qq_41827511的博客
12-08 151
子进程创建的三种方法 实现Runnable接口 package com.it_51; public class Runner implements Runnable { //编写执行代码 @Override public void run(){ for(int i=0;i<10;i++){ //打印次数和线程名称 ...
基于Java的多线程编程性能分析
最新发布
12-16
本文主要围绕Java多线程编程在特定算法—MD5哈希算法下的性能表现进行了深入的分析。 首先，文章提出了研究的背景和方案，通过对Java多线程编程的理论分析和实验验证，探索其在不同线程数量下的计算性能。在多个...
Java中join线程操作实例分析
08-25
Join线程操作是Java多线程编程中的一种重要机制，它允许一个线程等待另外一个线程完成。通过join()方法，可以实现线程之间的同步操作。 在Java中，线程可以通过join()方法来等待其他线程的完成。join()方法通常由...
详解Java多线程处理List数据
08-26
Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List数据的知识点。 一、什么是...
Java实现多线程轮流打印1-100的数字操作
09-07
本文将详细讲解如何使用Java实现多线程轮流打印1-100的数字，以及在此过程中遇到的并发问题及其解决方案。 首先，我们要理解基本的Java线程创建和运行方式。在示例代码中，通过`Thread`类和`Runnable`接口创建了多...
JAVA的多线程操作
雪禅子
09-14 468
http://lavasoft.blog.51cto.com/62575/27069
Java 多线程操作
wuyouke的专栏
09-10 363
在介绍多线程之前，先介绍并发和并行的区别： 并发：是指在某一段时间内发生多个事件； 并行：是指在同一时刻发生多个事件； 在操作系统中，有多个CPU，可以并发进行多程序的并发执行，而单CPU，只能进行CPU资源的调度，并行执行程序； 进程和线程的区别： 进程：拥有自己独立的内存空间； 线程：最小的CPU调度单位 多线程实现方式： 1）继承于java.lang.Thread 定义类，...
java 多线程操作
chaoyue1397的博客
02-15 677
大家过年好.新年一帆风顺! 工作中的某个需要多线程操作的功能,记录一下(简略代码)利用线程池 ExecutorService 产生一个有固定线程数的线程池其中如果任务多余线程数量进行队列分块进行解决. public class ProcessListUtil{ public Map manyProcessForCloud(String[] task,XmlRpcClientConfigImp
Java的多线程操作 一
wszhm123的博客
03-01 218
在开发的有时候，我们都会遇到系统需要处理非常多的执行时间很短的请求，如果每一个请求都开启一个新线程的话，系统就要不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会比线程真正执行的时间还长。而且当线程数量太多时，系统不一定能受得了。使用线程池主要为了解决一下几个问题：通过重用线程池中的线程，来减少每个线程创建和销毁的性能开销。对线程进行一些维护和管理，比如定时开始，周期执行，并发数控制等等...
java 线程 操作_java多线程操作
weixin_42425824的博客
02-20 157
进程是程序的一次动态的执行过程,它经历了从代码加载、执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。多线程是实现并发机制的一种有效的手段。进程和线程一样，都是实现并发的一个基本单位。如果现在同时运行多个任务，则所有的系统资源将是共享的，补所有线程所公用，但是程序处理需要CPU，传统的单核CPU来说 ，在同一个时间段上会有多个程序执行，但是在同一个时间点上只能存在一个程序运...
java线程操作_java多线程的操作
weixin_34986860的博客
02-26 200
上篇博客简单了介绍了Java的多线程的概念，与进程的区别，两种创建方式，状态及获取线程名称等内容。这篇文章接着介绍Java的多线程。主要从一下几方面介绍。1 线程类的常用方法1.1 start()启动线程执行run方法1.2Thread.sleep()/sleep(long millis)当前线程睡眠/millis的时间(millis指定睡眠时间是其最小的不执行时间，因为sleep(millis...
Java多线程休眠操作经典案例分析
标题中提到的知识点是Java多线程编程中的一个具体操作——设置线程休眠。在Java中，多线程是实现程序并发执行的重要机制。所谓线程休眠，指的是让当前执行的线程暂停一段时间不执行，让出CPU资源给其他线程使用，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值