Java-多线程汇总（创建、安全问题、等待唤醒机制、成员方法）

已于 2023-03-06 15:11:34 修改
阅读量147 收藏
点赞数
分类专栏： JAVA 文章标签： 学习 java
于 2023-02-22 10:02:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmh1028/article/details/129154805
版权

目录

线程的七大状态

 一、多线程的创建

          并发：同一时刻，多个指令在单个cpu交替执行

          并行：同一时刻，多个指令在多个cpu同时执行

        1.1、继承Thread的方式

        1.2、Runnable接口方式

        1.3、实现Callable接口

二、多线程中的常用成员方法

三、多线程中的线程安全问题

        3.1sychronized(锁)解决线程安全问题：

         主要问题：

        问题形成主要原因：

        解决办法：

        同步代码块代码实现：

        同步方法代码实现：

        3.2使用Lock锁解决线程安全问题

四、多线程中的等待唤醒机制

        4.1常规方式实现

 实例代码：

        4.2阻塞队列的方式实现

线程的七大状态

 

 一、多线程的创建

          并发：同一时刻，多个指令在单个cpu交替执行

          并行：同一时刻，多个指令在多个cpu同时执行

        1.1、继承Thread的方式

public static void main(String[] args) {
        /*
        多线程第一种启动方式
        1.自己定义一个类继承Thread
        2.重写run方法
        3.创建子类对象，启动线程
         */
        MyThread t1 =new MyThread();
        MyThread t2 =new MyThread();
        t1.setName("线程1");
        t1.setName("线程2");
        t1.start();
        t2.start();
    }
public class MyThread extends Thread{
    @Override
    public void run() {
        //书写线程要执行代码
        for (int i = 0 ; i < 100 ; i++){
            System.out.println(getName()+"abc");
        }
    }
}

        1.2、Runnable接口方式

public class ThreadDemo {
    public static void main(String[] args) {
 多线程第二种启动方式
        1.自己定义一个类实现Runnable接口
        2.重写run方法
        3.创建自己的类对象
        4.创建一个Thread类的对象，并开启线程
         */

        //创建MyRun的对象
        //表示多线程要执行的任务
        MyRun mr = new MyRun();
        Thread t3 =new Thread(mr);
        Thread t4 =new Thread(mr);
        t3.setName("线程3");
        t4.setName("线程4");
        t3.start();
        t4.start();
 }
}

public class MyRun implements Runnable {
    @Override
    //书写程序要执行的代码
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "Hello");
            //Thread.currentThread()返回当前线程的对象
        }
    }
}

        1.3、实现Callable接口

package Threads;

import Threads.MyRun;

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

public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
 /*
        多线程的第三种实现方式
        特点：可以获取多线程运行的结果
        1.创建一个MyCallable实现Callable接口
        2.重写Call(该方法具有返回值，表示多线程运行的结果）
        3.创建MyCallable的对象（表示多线程要执行的任务）
        4.创建FutureTask的对象（作用管理多线程运行的结果）
        5.创建Thread类的对象，并启动（表示线程）
         */
        MyCallable mc = new MyCallable();
        FutureTask<Integer> ft =new FutureTask<>(mc);
        Thread t5 = new Thread(ft);
        t5.start();
        Integer result = ft.get();
        System.out.println(result);

    }
}


import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        //求1~100的和
        int sum =0;
        for (int i = 1; i <=100; i++) {
            sum = sum + i;
        }
        return sum;
    }
}

二、多线程中的常用成员方法

 

三、多线程中的线程安全问题

        3.1sychronized(锁)解决线程安全问题：

         需求：三个窗口售卖100张电影票

         主要问题：

                1.多个窗口售卖同一张票

                2.售卖票数超过规定票数

        问题形成主要原因：

                线程执行时，具有随机性，CPU的执行权随时可能发生抢占。

        解决办法：

                同步代码块/同步方法

                使用

                sychronized(锁){

                操作共享数据的代码

                }

                特点1：锁默认打开，有一个线程进去了，锁自动关闭。

                特点2：里面代码全部执行完毕，线程出来，锁自动打开。

        同步代码块代码实现：

        ThreadDemo.java文件        

package Thread_safe;

public class ThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
        Mythread t1 =new Mythread();
        Mythread t2 =new Mythread();
        Mythread t3 =new Mythread();
        //给线程对象设置名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        //开启线程
        t1.start();
        t2.start();
        t3.start();

    }
}

        MyThread.java

package Thread_safe;

public class Mythread extends Thread{
    //static修饰表示这个类的所有对象，都共享ticket的数据
    static int ticket = 0 ;//0~99
    //创建锁对象，一定要是唯一的
    static Object obj = new Object();

    @Override
    public void run() {
        while (true){
            //同步代码块
            synchronized (obj){
                if (ticket<100) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName() + "正在售卖第" + ticket + "张票");
                }
                 else {
                     break;
                }
            }
        }
    }
}

        同步方法代码实现：

        ThreadDemo.java文件

package Thread_safe;

public class ThreadDemo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        Thread t3 = new Thread(mr);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();

    }
}

        MyRunnable.java文件

package Thread_safe;

public class MyRunnable implements Runnable{
    int ticket = 0;
    public void run() {
        while (true){
            //同步方法
            if (method()) break;
        }
    }

    private synchronized boolean method() {
        if (ticket<100) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket++;
            System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
        }
        else {
            return true;
        }
        return false;
    }

}

        3.2使用Lock锁解决线程安全问题

 对比synchronizedk()方法和语句可以获得更广泛的锁定操作

Lock中提供了获得锁和释放锁的方法

void lock()        获得锁

void unlock()    释放锁

Lock()是接口，不能直接实例化，采用他的实现类ReentrantLock来实例化

ReentrantLock的构造方法：

ReentrantLock():创建一个ReentrantLock的实例。

示例代码：

MyRunnable.java

package Thread_safe;

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

public class MyRunnable implements Runnable{
    int ticket = 0;
    Lock lock =new ReentrantLock();
    public void run() {
        while (true){
            //同步方法
            if (method()) break;
        }
    }

    private  boolean method() {

        lock.lock();
        if (ticket<100) {
            try {
                Thread.sleep(100);
                ticket++;
                System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }finally {
                lock.unlock();//将unlock放入finally中避免进程跳出循环时直接跳过unlock导致程序无法结束

            }
        }
        else {
            return true;
        }
        return false;
    }

}

ThreadDemo.java

    package Thread_safe;

    public class ThreadDemo {
        public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        Thread t3 = new Thread(mr);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();

    }
}

四、多线程中的等待唤醒机制

        4.1常规方式实现

 原理图解：

基本方法：

 实例代码：

Cook.java文件

package wait_and_notify;

import sun.security.krb5.internal.crypto.Des;

public class Cook extends Thread{
    @Override
    public void run() {
        while (true){
            synchronized (Desk.lock){
                if (Desk.count==0){
                    break;
                }else {
                    if (Desk.foolFlag==1){
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else {
                        System.out.println("做好了一碗面条");
                        Desk.foolFlag=1;
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

Desk.java文件:

package wait_and_notify;

public class Desk {
    //0表示没有面条，1表示有面条。
    public static int foolFlag = 0;
    //锁对象创建
    public static Object lock =new Object();
    //总数
    public static int count = 10;

}

Foodie.java文件

package wait_and_notify;

public class Foodie extends Thread {
    @Override
    public void run() {
        while (true){
            synchronized (Desk.lock){
                if (Desk.foolFlag==0){
                    try {
                        Desk.lock.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }else {
                    Desk.count--;
                    System.out.println("正在吃，还能吃："+Desk.count+"碗面条");
                    Desk.lock.notifyAll();
                    Desk.foolFlag=0;
                }
            }
        }
    }
}

ThreadDemo.java文件

package wait_and_notify;

public class ThreadDemo {
    public static void main(String[] args) {
        Foodie f1 =new Foodie();
        Cook c1 =new Cook();
        f1.start();
        c1.start();
    }
}

        4.2阻塞队列的方式实现

Cook.java文件

package wait_and_notify_ArrayBlockingQueue;

import java.util.concurrent.ArrayBlockingQueue;

public class Cook extends Thread{
    ArrayBlockingQueue<String> queue;
    public Cook(ArrayBlockingQueue<String>queue){
        this.queue=queue;
    }

    @Override
    public void run() {
        while (true){
            try {
                queue.put("面条");
                System.out.println("放了一碗面条");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }
}

Foodie

package wait_and_notify_ArrayBlockingQueue;

import java.util.concurrent.ArrayBlockingQueue;

public class Foodie extends Thread{
    ArrayBlockingQueue<String> queue;
    public Foodie(ArrayBlockingQueue<String>queue){
        this.queue=queue;
    }

    @Override
    public void run() {
        while (true){

            try {
                String food = queue.take();
                System.out.println(food);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }
}

ThreadDemo.java

package wait_and_notify_ArrayBlockingQueue;

import java.util.concurrent.ArrayBlockingQueue;

public class ThreadDemo {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> queue =new ArrayBlockingQueue<>(1);
        Cook c = new Cook(queue);
        Foodie f = new Foodie(queue);
        c.start();
        f.start();
    }
}

MMH01
关注
专栏目录
JAVA多线程汇总
孤独天狼的博客
05-07 490
一、概念解释 1.主线程:JVM调用程时所产生的线程。2.当前线程:指通过Thread.currentThread()来获取的进程。 3.后台线程:为其它线程提供服务的线程也成为守护线程。JVM的垃圾回收线程就是后台线程。4.前台线程:是指接受后台线程服务的线程，可以通过isDaemon()和setDaem......
java多线程汇总_Java多线程编程基础知识汇总
weixin_33076057的博客
02-13 113
多线程简介多任务现代操作系统(Windows、Linux、MacOS)都可以执行多任务，多任务就是同时运行多个任务。例如在我们的计算机上，一般都同时跑着多个程序，例如浏览器，视频播放器，音乐播放器，Word办公软件等等，由于CPU执行代码都是一条一条顺序执行的，即时是单核CPU也可以同时执行多个任务，操作系统执行多个任务实际上就是轮流让多个任务交替执行。即使是多核CPU，因为通常任务的数量是远多于...
Java 多线程知识汇总-理解版
大数据开发
06-12 360
本文主要整理博主遇到的Java多线程的相关知识点，适合速记，故命名为“小抄集”。本文没有特别重点，每一项针对一个多线程知识做一个概要性总结，也有一些会带一点例子，习题方便理解和记忆。1. interrupted与isInterrupted的区别interrupted()：测试当前线程是否已经是中断状态，执行后具有状态标志清除为false的功能。isInterrupted()：测试线程Thread对...
java多线程处理汇总
iteye_8936的博客
01-24 470
基于对多线程的使用和理解，对多线程使用的的类做了一个归类，并对相关内容进行一个简单的分解，如果需要详细了解，请自己查询相关资料。   上图是大家经常在多线程中或者编程中使用的类 变量 一个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个 对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存 变量的具体值load到线程本地内存中...
Java 多线程基础汇总
qq_36142320的博客
04-06 242
### 第一题： /** * 1、经典多线程题目。 * * 启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10, * 然后是线程3打印11,12,13,14,15. * 接着再由线程1打印16,17,18,19,20….以此类推, 直到打印到75 * */ public class Thread02 { ...
Java常见面试题汇总-----------Java多线程（多线程同步机制）
知行流浪
04-20 2886
39、Synchronized的底层原理   synchronized是JAVA中解决并发编程中最常用的方法。   synchronized的作用如下：   1、确保线程互斥访问同步代码；   2、保证共享变量的修改能够及时可见；   3、有效解决指令重排序问题。   synrhronized关键字简洁、清晰、语义明确，因此即使有了Lock接口，使用的还是非常广泛。其应用层的语义是可以把任何一个非...
Java线程等待用法实例分析
08-27
Java线程等待用法实例分析是Java多线程编程中的一种重要机制，用于控制线程之间的同步和通信。通过使用wait()、notify()和notifyAll()方法，可以实现线程之间的协调和同步，从而避免线程之间的冲突和死锁。 在Java...
火爆大厂的100道Java面试题及答案(2022年整理，持续更新) --多线程并发篇
q1472750149的博客
12-29 3983
前言：这是一个基本涵盖Java初中级大部分核心知识点的面试题集，包含了Java基础、容器、多线程、Spring、SpringBoot、MyBatis、Linux、MySQL、Redis、MongoDB、网络协议、JVM等方向。所有题目都是我亲自整理的。 因为无法生成自动跳转的目录，同时我也按照分类汇总整理成了PDF版，排版上相比更加整齐并且带有书签 阅读起来也比较方便全部。前前后后花费半个月的时间，共计24W字。 收藏的时候，顺便点个赞呗~ 收藏的时候，顺便点个赞呗~ 收藏的时候，顺便点个赞呗~
java多线程并发
weixin_48288539的博客
10-27 3277
介绍java线程并发机制
Java多线程详解
weixin_44530708的博客
02-10 1356
java多线程问题分析与共享
详解Java多线程处理List数据
08-26
主要介绍了Java多线程处理List数据，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java多线程总结
qq_45661125的博客
05-11 658
多线程并行与并发上下文切换进程与线程多线程的好处多线程的应用场景Thread类的常见方法多线程的基本使用线程的状态 state线程的创建 new线程的启动 start（）线程的休眠 sleep（）线程的等待 join（）线程的中断 Interrupt线程通信 wait（）notify（）线程安全多线程不安全的原因解决线程不安全问题volatile关键字synchronized 关键字（监视器锁monitor lock）lock（）手动加锁公平锁和非公平锁synchronized和lock的区别 并行与并发
java多线程相关问题汇总
有图有真相
06-20 3047
1、线程和进程的关系 根本区别：进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位。 资源开销：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。 包含关系：如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线...
Java多线程处理并汇总处理结果
最新发布
billxin0621的博客
11-24 2021
在业务逻辑处理时，经常会for循环处理多条数据（如2000条），当每一条数据处理时间略微长时（0.1s），整体时间就会比较长了（200s）如果开10个线程处理时，整体时间就可以缩短10倍，整体只需要20s就可以完成了因此，本篇文章就介绍一下如何更好的多线程处理，以缩短处理时间。
java最后一个线程汇总数据_Java线程汇总
weixin_42311000的博客
02-25 302
1、多线程介绍多线程优点资源利用率好程序设计简单服务器响应更快多线程缺点设计更复杂上下文切换的开销增加资源消耗线程需要内存维护本地的堆栈，同时需要操作系统资源管理线程。2、并发模型并发系统可以有多种并发模型，不同的并发模型在处理任务时，线程间的协作和交互的方式也不同。并行工作者委托者将任务分配到不同的现场去执行,每个工作者完成整个任务。工作者们并行运作在不同的线程上，甚至可能在不同的CPU上。如图...
JAVA多线程执行结果汇总，多线程执行，将结果汇总后返回给主线程
尽量致力于发表微服务、中间件和算法等原创作品。
06-01 9486
/** * 多线程执行结果汇总工具 * * @author 张帅 * @date 2021年05月20日 11时28分02秒 * @version V1.0 * * @param <T> */ @Slf4j public class MultiFutureThread<T> { // 总线程数量 private int threadSize; // 单次执行多少次线程 private int singleSize; ...
编译rk3588_buildroot报错
YY2065的博客
08-24 1982
【代码】编译rk3588_buildroot报错。
Java中的多线程你只要看这一篇就够了
aikuangchou2298的博客
05-10 4925
引 如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文的范围之内。 用多线程只有一个目的，那就是更好的利用cpu的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应“多角色”的程序代码，最起码每个角色要给他一个线程吧，否则连实际场景都无法模拟，当然也没法说能用单线程来实现：比如最常见的“生产者，消费者模型”。 很多人都对...
Java多线程超详细总结
star_zhang_jx的博客
09-05 1228
多线程概述 多线程是Java的特点之一，掌握多线程编程技术，可以充分利用CPU的资源，更容易解决实际问题，并且多线程技术广泛应用于网络相关的程序设计中。 进程 进程是程序的一次动态执行过程，它对应了从代码加载、执行至完毕的一个完整过程，这个过程也是进程本身从产、发展至消亡的过程。 线程 线程是比进程更小的执行单位，一个进程在其执行过程中，可以产生多个线程，形成多条执行线索，每条线索，即每个线程，也有它自身产生、存在和消亡的过程。与进程可以共享操作系统的资源类似，线程间也可以共享进程中的某些内存单元（包括代码
Java多线程：同步方法解决线程安全问题深入解析
"Java多线程中使用同步方法来解决线程安全问题的案例分析" 在Java多线程编程中，线程安全是一个至关重要的概念，特别是在多个线程访问共享资源时。为了确保数据的一致性和完整性，Java提供了多种同步机制，其中之一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值