并发编程（一）：初识多线程及线程通信

最新推荐文章于 2023-03-06 23:19:12 发布
最新推荐文章于 2023-03-06 23:19:12 发布
阅读量121 收藏 2
点赞数
分类专栏： 并发编程 文章标签： Java 并发编程 多线程 线程通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011976388/article/details/101312583
版权

一，线程三种启动方式

    1，Thread方式

package com.gupao.concurrent;

/**
 * @author pj_zhang
 * @create 2019-09-24 21:06
 **/
public class StartThread extends Thread {

    @Override
    public void run() {
        System.out.println("Thread方式执行线程。。。");
    }

    public static void main(String[] args) {
        // 普通方式执行
        new StartThread().start();
        // lamdo表达式执行
        new Thread(() -> {
            System.out.println("lamdo: Thread方式执行线程。。。");
        }).start();
    }
}

    2，Runnable方式

package com.gupao.concurrent;

/**
 * @author pj_zhang
 * @create 2019-09-24 21:12
 **/
public class StartRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable方式执行线程。。。");
    }

    public static void main(String[] args) {
        new Thread(new StartRunnable()).start();
    }
}

    3，Callable方式 -- 带返回值

        * 不同于Thread和Runnable方式，Callable执行线程后可以返回线程执行结果

        * 通过返回结果Funture去get()结果集时，会阻塞直到结果返回

package com.gupao.concurrent;

import java.util.concurrent.*;

/**
 * @author pj_zhang
 * @create 2019-09-24 21:13
 **/
public class StartCallable implements Callable {
    @Override
    public Object call() throws Exception {
        TimeUnit.SECONDS.sleep(3);
        return "Callable方式执行线程";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService service = new ThreadPoolExecutor(
                20, 20, 0L,
                TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        Long startTime;
        Long endTime;
        System.out.println("开始执行时间：" + (startTime = System.currentTimeMillis()));
        Future<?> future = service.submit(new StartCallable());
        String result = (String) future.get();
        System.out.println("执行结束时间" +  (endTime = System.currentTimeMillis()));
        System.out.println(result + ", cast: " + (endTime - startTime));
    }
}

二，线程声明周期（六种线程状态）

    1，线程状态

        * NEW（线程初始化）

        * RUNNABLE（线程运行）

            a，Ready（就绪）

            b，Running（运行）

            c，NEW -(start())-> RUNNABLE

            d，Ready -线程调度-> Running

            e，Running -(yield()/线程调度)-> Ready

        * TERMINATED（线程销毁）

        * BLOKED（线程阻塞状态，锁抢占）

             a，synchorized加锁

        * WAITING（线程等待）

             a，wait()

             b，join()

             c，LockSupport.park()

        * TIME_WAITING（线程限时等待）

             a，wait(Long)

             b，sleep(Long)

    2，线程状态转换演示_代码

package com.gupao.concurrent;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author pj_zhang
 * @create 2019-09-24 21:42
 **/
public class ThreadStatusTest {

    public static void main(String[] args) {
        // 运行时线程
        new Thread(() -> {
            for (;;) {}
        }, "THREAD_RUNNING").start();
        // 等待线程
        new Thread(() -> {
            try {
                Object object = new Object();
                synchronized (object) {
                    object.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "THREAD_WAITING").start();
        // 定时等待线程
        new Thread(() -> {
            try {
                Object object = new Object();
                synchronized (object) {
                    object.wait(60 * 60 * 1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "TIME_WAITING_THREAD").start();
        Lock lock = new ReentrantLock();
        // 未阻塞线程
        new Thread(() -> {
            synchronized (lock) {
                for (; ; ) {}
            }
        }, "NOT_BLOCKING_THREAD").start();
        // 阻塞线程
        new Thread(() -> {
            try {
                Thread.sleep(1000);
                synchronized (lock) {
                    for (;;) {}
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "BLOCKING_THREAD").start();
    }
}

    3，线程状态转换演示_状态查看

        * 通过 jps 命令查看正在执行的线程PID

        * 通过 jstack pid 命令，查看正在执行的所有线程及其状态

        * 从中可以依次看到定义中的几种线程状态

三，线程中断

    1，线程中断：thread.interrupt()

    2，判断线程是否中断：Thread.currentThread().isInterrupted()

    3，线程中断代码演示；如下代码，interrupt()提供了一种可控的方式对线程进行中断，执行中断操作后，被中断线程可以根据当前业务运行情况在对应安全点对线程中断操作进行响应

package com.gupao.concurrent;

/**
 * @author pj_zhang
 * @create 2019-09-24 22:33
 **/
public class ThreadInterruptTest {

    private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
                // 线程初始化后，默认中断状态为false
                // 等其他线程对当前线程执行中断操作后，线程状态变为true
                for (; !Thread.currentThread().isInterrupted(); ) {
                    i++;
                }
                System.out.println(i);
                // 打印当前线程中断状态
                System.out.println(Thread.currentThread().isInterrupted());
            });
        thread.start();
        // 主线程睡眠一秒后，对线程进行中断操作
        Thread.sleep(1000);
        thread.interrupt();
    }
}

    4，线程等待中的线程中断演示，会抛出 InterruptedException 异常，(异常后会对线程中断状态进行复位，在下一部分解释)

package com.gupao.concurrent;

/**
 * @author pj_zhang
 * @create 2019-09-24 22:33
 **/
public class ThreadWaitingInterruptTest {

    private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                // 线程等待十秒，主线程1秒后中断，则必定触发中断异常
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                // 异常后， 线程会自动复位
                // 主线程调用interrupt后，线程中断状态从false -> true
                // 由于触发异常，则对线程中断重新赋值为初始状态false
                System.out.println("响应线程中断。。。，线程中断状态："
                        + Thread.currentThread().isInterrupted());
            }
        });
        thread.start();
        // 主线程睡眠一秒后，对线程进行中断操作
        Thread.sleep(1000);
        thread.interrupt();
    }
}

四，线程复位

    1，线程中断是给执行一个中断信号，告诉执行线程已经进行了线程中断操作，具体后续操作由执行线程进行后续处理，执行线程在接收到线程中断信号后，可以对线程中断状态进行复位；

    2，线程复位两种方式

        a，API复位：Thread.interrupted()

package com.gupao.concurrent;

/**
 * @author pj_zhang
 * @create 2019-09-24 22:33
 **/
public class ThreadInterruptTest {

    private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
                // 线程初始化后，默认中断状态为false
                // 等其他线程对当前线程执行中断操作后，线程状态变为true
                for (; !Thread.currentThread().isInterrupted(); ) {
                    i++;
                }
                System.out.println(i);
                // 线程复位前中断状态
                System.out.println("before: " + Thread.currentThread().isInterrupted());
                // 线程复位
                Thread.interrupted();
                // 线程复位后中断状态
                System.out.println("after：" + Thread.currentThread().isInterrupted());
            });
        thread.start();
        // 主线程睡眠一秒后，对线程进行中断操作
        Thread.sleep(1000);
        thread.interrupt();
    }
}

        b，异常复位：等待中的线程接收到异常信号后，会抛出 InterruptedException 异常，捕获异常后线程状态已经由 JVM 复位，可继续进行后续处理，异常复位已经在上一部分演示；

五，线程通信

    1，线程等待和线程唤醒：wait()/notify()

package com.gupao.concurrent;

/**
 * @author pj_zhang
 * @create 2019-09-24 23:04
 **/
public class ThreadTelTest extends Thread {

    // 定义初始数量
    private static int i = 100;

    // 定义初始标志位
    // 此处模拟两道线程运行，通过简单标志位实现
    // 如果确实需要通过某种方式实现线程顺序执行，可以通过分布式锁实现
    // 参考之前博文中的zookeeper和redis分布式锁
    private static boolean flag = false;

    // 定义同步锁对象
    private static Object lock = new Object();

    public static void main(String[] args) {
        // 两道线程同时执行
        new Thread(new ThreadTelTest(), "售票员A").start();
        new Thread(new ThreadTelTest(), "售票员B").start();
    }

    @Override
    public void run() {
        try {
            for (;;) {
                synchronized (lock) {
                    if (i > 0) {
                        // flag为true，说明已经存在线程执行过，
                        // 当前线程为新线程或者被唤醒线程，且执行过的线程目前处于等待中
                        if (flag) {
                            System.out.println(Thread.currentThread().getName() + "卖出第" + i-- + "张票");
                            // 线程执行完成后，唤醒处于等待中线程
                            lock.notify();
                            // 当前线程等待，并释放锁对象，被唤醒的线程会直接抢占锁对象
                            lock.wait();
                        } else {
                            // flag为false，说明当前线程第一次进入，执行完业务代码后，修改flag表示为true
                            System.out.println(Thread.currentThread().getName() + "卖出第" + i-- + "张票");
                            flag = true;
                            // 线程等待，实现两道线程交替执行，因为是第一个进入的线程，不需要唤醒线程
                            lock.wait();
                        }
                    } else {
                        System.out.println("卖完了");
                        break;
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

    2，线程排队：join()

        * 线程排队执行代码演示

package com.gupao.concurrent;

/**
 * @author pj_zhang
 * @create 2019-09-24 22:52
 **/
public class ThreadJoinTest {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                // 通过不规则定时，演示线程随机执行
                Thread.sleep(200);
                System.out.println("线程一执行结束。。。");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(20);
                System.out.println("线程二执行结束。。。");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t3 = new Thread(() -> {
            System.out.println("线程三执行结束。。。");
        });
        // 通过 join 方法，保证线程排队执行
        t1.start();
        t1.join();
        t2.start();
        t2.join();
        t3.start();
        t3.join();
    }
}

        * join()方法内部；

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            // 从这一步可以看到，如果当前线程依旧存活，则阻塞主线程
            // 通过自旋一直等待直到线程执行结束
            while (isAlive()) {
                wait(0);
            }
        } else {
            // 这一部分表示限时阻塞
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

        * 从方法源码看，join()通过对主线程的阻塞实现线程方法的顺序执行，如果在上一步直接start()三道线程，再对线程逐一进行join()，则线程三会瞬间抢占时间片并执行，从而乱序，如图

传说中的靖哥哥
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
初识通信——多线程服务器的建立
03-26
在IT行业中，多线程服务器的建立是网络编程的一个重要组成部分，特别是在高并发场景下，如Web服务、游戏服务器等。本文将详细讲解如何初识通信，并以多线程服务器的构建为例，来阐述相关技术点。 首先，理解多线程...
golang-playground:玩转Golang并发现编程语言功能
04-01
3. **探索并发编程**：Go语言的一大亮点是其内置的goroutine和channel。goroutine是轻量级线程，用于实现并发执行，而channel则作为它们之间的通信桥梁。你可以编写代码来创建goroutine，通过channel进行同步，体验...
Java并发编程系列：线程的五大状态，以及线程之间的通信与协作
AD_plus的博客
07-29 289
今天主要分享多线程状态流转与通信，这也是面试中必考的基础知识点。 01 多线程的基本概念 1.进程 进程是操作系统进行资源分配和调度的基本单位。 2.线程 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。 3.多线程 什么是多线程呢？即就是一个程序中有多个线程在同时执行。 02 线程的生命周期 java中每个线程都需经历新生、就绪、运行、阻塞和死亡五种状态，线程从...
java并发编程：线程间通信
River的博客
06-04 344
摘要：线程与线程之间不是相互独立的个体，它们彼此之间需要相互通信和协作，最典型的例子就是生产者-消费者问题。本文首先介绍 wait/notify 机制，并对实现该机制的两种方式——synchronized+wait-notify模式和Lock+Condition模式进行详细剖析，以作为线程间通信与协作的基础。进一步地，以经典的生产者-消费者问题为背景，熟练对 wait/notify 机制的使用。最...
多线程与高并发编程之基础知识（上）
boker_han的博客
10-01 5万+
前言： 使用多线程，第一步就是需要知道如何实现自定义线程，因为实际开发中，需要线程完成的任务是不同的，所以我们需要根据线程任务来自定义线程，那么，JDK提供了三种自定义线程的方式，供我们实际开发中使用，来开发出符合需求的多线程程序！ 以下给出线程的三种实现方式，并且对每种实现的优缺点进行分析，最后对三种实现方式进行总结； 方式一：继承Thread类，重写run方法 package com.thr...
java并发编程一一多线程之间通讯(一)
若成风的博客
10-19 209
1.多线程之间如何实现通讯 多线程之间通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。
java高并发变成详解_Java高并发编程详解：多线程与架构设计
weixin_39936792的博客
02-26 153
推荐序一推荐序二推荐序三推荐序四前言第一部分 多线程基础第1章 快速认识线程1.1 线程的介绍1.2 快速创建并启动一个线程1.3 线程的生命周期详解1.4 线程的start方法剖析：模板设计模式在Thread中的应用1.5 Runnable接口的引入以及策略模式在Thread中的使用1.6 本章总结第2章 深入理解Thread构造函数2.1 线程的命名2.2 线程的父子关系2.3 Thread与...
java并发编程之初识线程
FOREVER_DO
08-07 753
java并发编程之初识线程说明线程生命周期线程创建线程间通信线程池生产者消费者实例 说明 操作系统运行一个程序就会创建一个进程，例如我们一个main函数程序启动了，就会创建一个java进程，然后有一个main主线程和其他线程（至少一个垃圾回收线程），这时我们如果想java做的任务更多时间更少就可以创建更多线程，这样能够最大化利用cpu,更快响应。 线程生命周期 线程创建 线程间通信 线程池 生产...
并发初体验-初识多线程
blackwq的博客
05-13 212
并发初体验-初识多线程1 实现多线程的三种方式1.1继承Thread类重写run方法1.2实现Runnable接口1.3实现Callable接口通过FutureTask包装器来创建Thread线程2 线程的生命周期3 显示线程的状态4 线程的终止interrupt()方法interrupted()方法 静心、砥砺前行 1 实现多线程的三种方式 1.1继承Thread类重写run方法 Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的
并发编程面试题（2020最新版）
热门推荐
ThinkWon的博客
03-14 36万+
文章目录基础知识并发编程的优缺点为什么要使用并发编程（并发编程的优点）并发编程有什么缺点并发编程三要素是什么？在 Java 程序中怎么保证多线程的运行安全？并行和并发有什么区别？什么是多线程，多线程的优劣？线程和进程区别什么是线程和进程?进程与线程的区别什么是上下文切换?守护线程和用户线程有什么区别呢？如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高？什么是线程死锁形成死锁的...
C++并发编程之一 初识线程和线程管控
Awesomewan的博客
03-06 247
C++并发编程探索
02python核心编程阶段-python基础.rar
07-30
- 并发编程：Python提供了线程(threading)、进程(multiprocessing)以及异步IO(asyncio)等方式来实现并发，提升程序执行效率。 6. **调试与测试**： - 调试工具：pdb是Python内置的调试器，可以设置断点、单步执行...
初识java,用springBoot学习java
08-28
- **多线程**：Java内置对多线程的支持，通过Thread类或Runnable接口实现并发编程。 2. **Spring Boot入门** - **自动配置**：Spring Boot的核心特性之一，根据项目依赖自动配置相关组件。 - **起步依赖**：通过...
1.初识Java.zip
05-31
此外，Java的并发处理能力强大，支持多线程编程。 7. **多线程** Java内置对多线程的支持，提供了Thread类和Runnable接口，使得开发者能轻松创建并管理多个并发执行的任务。 8. **动态性** Java允许程序在运行时...
udp分片报文pcap文件
07-18
udp分片报文pcap文件：64kudp大包分成每片658字节总计100片
计算机教学导案.doc
07-18
计算机
摩根：2024年大市前瞻.pdf
最新发布
07-18
摩根：2024年大市前瞻
计算机控制专业技术专题实习任务书温度控制.doc
07-18
计算机

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值