首页 > 资讯 > 后端开发 > Python >聊聊java多线程创建方式及线程安全问题

867

分享到

聊聊java多线程创建方式及线程安全问题

2024-04-02 19:04:59 867人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

什么是线程线程被称为轻量级进程，是程序执行的最小单位，它是指在程序执行过程中，能够执行代码的一个执行单位。每个程序程序都至少有一个线程，也即是程序本身。线程的状态新建（New）

什么是线程

线程被称为轻量级进程，是程序执行的最小单位，它是指在程序执行过程中，能够执行代码的一个执行单位。每个程序程序都至少有一个线程，也即是程序本身。

线程的状态

新建（New）：创建后尚未启动的线程处于这种状态
运行（Runable）：Runable包括了操作系统线程状态的Running和Ready，也就是处于此状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间。
等待（Wating）：处于这种状态的线程不会被分配CPU执行时间。等待状态又分为无限期等待和有限期等待，处于无限期等待的线程需要被其他线程显示地唤醒，没有设置Timeout参数的Object.wait()、没有设置Timeout参数的Thread.join()方法都会使线程进入无限期等待状态；有限期等待状态无须等待被其他线程显示地唤醒，在一定时间之后它们会由系统自动唤醒，Thread.sleep()、设置了Timeout参数的Object.wait()、设置了Timeout参数的Thread.join()方法都会使线程进入有限期等待状态。
阻塞（Blocked）：线程被阻塞了，“阻塞状态”与”等待状态“的区别是：”阻塞状态“在等待着获取到一个排他锁，这个时间将在另外一个线程放弃这个锁的时候发生；而”等待状态“则是在等待一段时间或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将进入这种状态。
结束（Terminated）：已终止线程的线程状态，线程已经结束执行。

多线程创建方法

继承Thread


class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println(currentThread().getName()+"运行了");
    }
}
class Test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        System.out.println(Thread.currentThread().getName()+"：运行了");
        myThread.start();
    }
}

实现Runable接口创建多线程


class MThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i<100;i++){
            if (i%2!=0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread = new Thread(mThread);
        thread.start();
    }
}

Thread和Runable创建多线程对比

开发中：优先使用Runable
1.实现的方式没有类的单继承的局限性。
2.实现的方式跟适合处理多个线程有共享数据的情况。
联系：Thread类中也实现了Runable，两种方式都需要重写run()。

实现Callable接口

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


class MCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum=0;
        for(int i=0;i<100;i++){
            sum+=i;
        }
        return sum;
    }
}
public class CallableTest {
    public static void main(String[] args) {
        //执行Callable 方式，需要FutureTask 实现实现，用于接收运算结果
        FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(new MCallable());
        new Thread(integerFutureTask).start();
        //接受线程运算后的结果
        Integer integer = null;
        try {
            integer = integerFutureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

与Runable相比，Callable功能更强大

相比run()方法可以有返回值
方法可以抛出异常
支持泛型的返回值
需要借助FutureTask类，比如获取返回结果

使用线程池进行创建

线程池创建的好处

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理：

corePoolSize:核心线程池的大小

maximumPoolSize:最大线程数

keepAliveTime:线程没有任务时最多保持多长时间后悔中止

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


class Thread1 implements Runnable{

    @Override
    public void run() {
        for (int i=1;i<30;i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService executorService= Executors.newFixedThreadPool(10);
        Thread1 threadPool = new Thread1();
        for (int i=0;i<5;i++){
            //为线程池分配任务
            executorService.submit(threadPool);
        }
        //关闭线程池
        executorService.shutdown();
    }
}

Thread中的常用方法start()：

start()：启动当前线程；调用当前线程的run();
run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。
currentThread()：静态方法，返回当前代码的线程。
getName()：获取当前线程的名字。
setName()：设置当前线程的名字。
yield()：释放当前cpu的执行权，切换线程执行。
join()：在线程a中调用线程b的join(),此时线程a会进入阻塞状态，知道线程b完全执行完毕，线程a 才结束阻塞状态。
stop()：强制线程生命期结束。（过时了，不建议使用）
isAlive()：判断线程是否还活着。
sleep(long millitime)：让当前线程睡眠指定的事milltime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。

线程的优先级

线程的优先级等级

MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5

涉及的方法

getPriority()：返回线程的优先值
setPriority(int newPriority)：改变线程的优先级

说明

线程创建时继承父线程的优先级
低优先级知识获得调度的概率低，并非一定是在高优先级线程之后才被调用

线程的同步

多线程卖票

基于实现Runable的方式实现多线程买票

package demo2;


class Thread2 implements Runnable{

    private  int ticket=100;
    @Override
    public void run() {
        while (true){
            if (ticket>0) {
                System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}
public class Test1 {
    public static void main(String[] args) {
        Thread2 thread2 = new Thread2();
        Thread t1 = new Thread(thread2);
        Thread t2 = new Thread(thread2);
        Thread t3 = new Thread(thread2);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

实现结果，存在重复的票

如果在买票方法中加入sleep函数

public void run() {
        while (true){
            if (ticket>0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }

则运行结果可能会出现-1，表示也是不正常的

理想情况

极端情况

在java中，我们通过同步机制，来解决线程的安全问题。

同步代码块

synchronized(同步监视器){
	//需要被同步的代码
}

说明

操作共享数据的代码就是需要被同步的代码。
共享数据：多个线程共同操作的变量，比如本题中的ticket就是共享数据。
同步监视器：俗称：锁。任何一个类的对象都可以充当锁。要求：多个线程必须要共用统一把锁。
同步的方式，解决了线程的安全问题---好处。但是操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。-----局限性
使用Runable接口创建多线程的方式中，可以使用this关键字；在继承Thread类中创建多线程中，慎用this充当同步监视器，可以考虑使用当前类充当同步监视器。Class clazz = windows.class 因此类也是一个对象
包裹操作共享数据的代码 不能多也不能少

修改之后的代码：

package demo2;


class Thread2 implements Runnable{

    private  int ticket=100;

    Object object = new Object();
    @Override
    public void run() {
        while (true){
            synchronized(object) { //括号中的内容可以直接使用当前对象this去充当
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class Test1 {
    public static void main(String[] args) {
        Thread2 thread2 = new Thread2();
        Thread t1 = new Thread(thread2);
        Thread t2 = new Thread(thread2);
        Thread t3 = new Thread(thread2);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

结果

继承Thread的方式，去使用同步代码块，需要将声明的锁对象设为statci，否则创建的对象的同步监视器不唯一，就无法实现。

package demo2;


class WindowsTest2 extends Thread{
    private static int ticket=100;
    private static   Object obj = new Object();

    @Override
    public void run() {
        while (true){
            synchronized (obj){ //这里不能使用this去充当，可以直接写一个Test.class   类也是对象
                if (ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName()+":买票，票号为："+ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}
public class  Test2{
    public static void main(String[] args) {
        WindowsTest2 w1 = new WindowsTest2();
        WindowsTest2 w2 = new WindowsTest2();
        WindowsTest2 w3 = new WindowsTest2();
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}

同步方法

如果操作共享数据的代码完整的声明在一个方法中，可以将此方法声明为同步的。

通过实现Runable的方式实现同步方法。

package demo2;


class Thread3 implements Runnable {

    private int ticket = 100;


    @Override
    public void run() {
        while (true) {
            show();
        }

    }
    private synchronized void show(){
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
            ticket--;
        }
    }
}

public class Test3 {
    public static void main(String[] args) {
        Thread3 thread3 = new Thread3();
        Thread t1 = new Thread(thread3);
        Thread t2 = new Thread(thread3);
        Thread t3 = new Thread(thread3);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

通过实现继承Thread的方式实现同步方法。使用的同步监视器是this，则不唯一，就会报错。所以将该方法定义为static。当前的同步换时期就变成Test4.class了

package demo2;


class WindowsTest4 extends Thread{
    private static int ticket=100;
    private static   Object obj = new Object();

    @Override
    public void run() {
        while (true){
            show();
        }

    }
    public static synchronized void show(){//同步监视器不是this了，而是当前的类
//    public synchronized void show(){//同步监视器是this  ，t1,t2,t3
        if (ticket>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":买票，票号为："+ticket);
            ticket--;
        }
    }
}
public class  Test4{
    public static void main(String[] args) {
        WindowsTest4 w1 = new WindowsTest4();
        WindowsTest4 w2 = new WindowsTest4();
        WindowsTest4 w3 = new WindowsTest4();
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}

总结

同步方法仍然设计到同步监视器，只是不需要我们去显示的声明。
非静态的同步方法，同步监视器是：this静态的同步方法中，同步监视器是类本身。

Lock锁解决线程安全问题

synchronize与lock的异同

相同

都可以解决线程安全问题

不同

synchronize机制在执行相应的同步代码以后，自动的释放同步监视器；Lock需要手动的启动同步lock(),同时结束同步也需要手动的实现unlock()。

建议优先使用顺序
Lock------>同步代码块（已经进入了方法体，分配了相应资源）---->同步方法（在方法体之外）

package demo2;

import java.util.concurrent.locks.ReentrantLock;


class Lock1 implements Runnable{
    private int ticket=50;

    //1.实例化
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try {
                //2.调用lock锁定方法
                lock.lock();
                if (ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"售票，票号为："+ticket);
                    ticket--;
                }else{
                    break;
                }
            } finally {
                //3.调用解锁方法
                lock.unlock();
            }
        }
    }
}
public class LockTest1 {
    public static void main(String[] args) {
        Lock1 lock1 = new Lock1();
        Thread t1 = new Thread(lock1);
        Thread t2 = new Thread(lock1);
        Thread t3 = new Thread(lock1);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();

    }
}

到此这篇关于聊聊java多线程创建方式及线程安全问题的文章就介绍到这了,更多相关java多线程创建内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 聊聊java多线程创建方式及线程安全问题

本文链接: https://www.lsjlt.com/news/161564.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

聊聊java多线程创建方式及线程安全问题

什么是线程线程被称为轻量级进程，是程序执行的最小单位，它是指在程序执行过程中，能够执行代码的一个执行单位。每个程序程序都至少有一个线程，也即是程序本身。线程的状态新建（New）...

99+

2022-11-12
java多线程创建及线程安全详解

什么是线程线程被称为轻量级进程，是程序执行的最小单位，它是指在程序执行过程中，能够执行代码的一个执行单位。每个程序程序都至少有一个线程，也即是程序本身。线程...

99+

2022-11-12
Java多线程之线程安全问题

文章目录一. 线程安全概述1. 什么是线程安全问题2. 一个存在线程安全问题的程序二. 线程不安全的原因和线程加锁1. 案例分析2. 线程加锁2.1 理解加锁2.2 synchroni...

99+

2023-09-21

java 线程安全多线程 synchronized jvm
Java创建多线程局域网聊天室实例

局域网聊天室在学习了一个学期的java以后，觉得java真是博大精深，彻底放弃了因为c++而轻视java的心态，搞了一个多线程的聊天室，熟悉了一下服务器和客户机的操作。 1.TCP...

99+

2022-11-12
Java多线程 - 线程安全和线程同步解决线程安全问题

文章目录线程安全问题线程同步方式一: 同步代码块方式二: 同步方法方式三: Lock锁线程安全问题线程安全问题指的是: 多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。举例:...

99+

2023-08-20

java 安全 jvm
Java多线程之线程安全问题详情

目录1.线程安全概述1.1什么是线程安全问题1.2一个存在线程安全问题的程序2.线程加锁与线程不安全的原因2.1案例分析2.2线程加锁2.2.1什么是加锁2.2.2如何加锁2.2.3...

99+

2022-11-13
Java多线程之线程安全问题详解

目录1. 什么是线程安全和线程不安全？2. 自增运算为什么不是线程安全的？3. 临界区资源和竞态条件总结：面试题：什么是线程安全和线程不安全？自增运算是不是线程安全的？如何保证多线...

99+

2022-11-13
怎么用Java创建多线程局域网聊天室

这篇文章主要讲解了“怎么用Java创建多线程局域网聊天室”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“怎么用Java创建多线程局域网聊天室”吧！局域网聊天室在学习了一个学期的java以后，觉...

99+

2023-06-20
Java多线程的创建方式

这篇文章主要介绍“Java多线程的创建方式”，在日常操作中，相信很多人在Java多线程的创建方式问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Java多线程的创建方式”的疑惑有所帮助！接下来，请跟着小编一起来...

99+

2023-06-20
Java多线程之线程安全问题怎么解决

本篇内容主要讲解“Java多线程之线程安全问题怎么解决”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Java多线程之线程安全问题怎么解决”吧!1.线程安全概述1.1什么是线程安全问题首先我们需要...

99+

2023-06-30
Java多线程编程中的并发安全问题及解决方法

目录线程安全性死锁定义实现一个死锁查看死锁解决死锁其他线程安全问题单例模式线程安全性线程安全是指我们所写的代码在并发情况下使用时，总是能表现出正确的行为；反之，未实现线程安全的代码...

99+

2023-05-16

Java多线程并发安全 Java并发安全问题 Java多线程并发
Java多线程中线程安全问题的示例分析

这篇文章主要介绍了Java多线程中线程安全问题的示例分析，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。1. 什么是线程安全和线程不安全？什么是线程安全呢？当多个线程并发访问某...

99+

2023-06-29
java创建多线程的七种方式

一、继承Thread，重写run方法通过自定义一个类（这里起名为：MyThread），继承Thread类，重写run方法，最后在main方法中new出MyThread实例，调用这个实例的继承的Thread类的start方法创建一个线程。 ...

99+

2023-09-26

java
Java 单例模式线程安全问题

Java 单例模式线程安全问题SpringIOC容器默认提供bean的访问作用域是单例模式。即在整个application生命周期中，只有一个instance。因此在多线程并发下，会有线程安全风险。我们在MVC框架下的servlet就是线程...

99+

2023-05-31

java 单例模式线程安全
Java的线程与进程以及线程的四种创建方式

目录问题描述case 代码截图数据库DOcontroller定义dao定义mapper实现mysql相关 properties配置数据库数据测试结果具体错误信息解决总结问题描述这里...

99+

2022-11-13
Java多线程中线程的两种创建方式及比较代码示例

线程的概念：线程(thread)是指一个任务从头至尾的执行流，线程提供一个运行任务的机制，对于java而言，一个程序中可以并发的执行多个线程，这些线程可以在多处理器系统上同时运行。当程序作为一个应用程序运行时，java解释器为main()方...

99+

2023-05-30

java 多线程创建
java创建多线程的方式有哪些

Java创建多线程的方式有以下几种：1. 继承Thread类：创建一个类继承Thread类，并重写run()方法，然后创建该类的对象，调用start()方法启动线程。```javaclass MyThread extends Threa...

99+

2023-08-09

java
Java多线程下解决数据安全问题

目录同步代码块同步方法lock锁同步代码块基本语句 synchronized (任意对象) { 操作共享代码 } 代码示例 public class SellTicket ...

99+

2022-11-12
Java线程安全问题的解决方案

目录线程安全问题演示解决线程安全问题1.原子类AtomicInteger2.加锁排队执行2.1 同步锁synchronized2.2 可重入锁ReentrantLock3.线程本地变...

99+

2022-11-13
Java创建线程及配合使用Lambda方式

目录一、创建线程三种方式1.1 继承Thread类创建线程类1.2 通过Runnable接口创建线程类使用Lambda表达式1.3 通过Callable和Future创建线程使用La...

99+

2022-11-12