如何创建多线程以及解决线程安全问题

最新推荐文章于 2024-05-13 19:46:54 发布
最新推荐文章于 2024-05-13 19:46:54 发布
阅读量387 收藏 1
点赞数 1
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43430343/article/details/118582391
版权

多线程

并发：指两个或多个事件在同一时间段内发生（交替执行）

并行：指两个或多个事件在同一时刻发生（同时发生）（一起同行）

image-20210707100652738

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

线程与进程

**进程：**是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

image-20210707101256497

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

image-20210707102329236

线程调度

  • 分时调度

    所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

  • 抢占式调度

    优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

创建线程类

主线程：执行主（main）方法的线程

单线程程序：java程序中只有一个线程，执行从main方法开始，从上到下依次执行

image-20210707104839704

创建多线程程序的第一种方式：创建Thread类的子类

java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类

实现步骤：

​ 1、创建一个Thread类的子类

​ 2、在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）

​ 3、创建Thread类的子类对象

​ 4、调用Thread类中的方法start方法，开启新的线程，执行run方法

​ void start() 使此线程开始执行; Java虚拟机调用此线程的run方法。

​ 结果是两个线程并发的执行（交替执行）；当前线程 （main线程）和另一个线程（创建的新线程，执行其run方法）。

​ 注意： 1、多次启动一个线程是非法的，特别是当线程已经结束执行后，不能再重新启动。

​ 2、java程序属于抢占式调度，哪个线程的优先级高，哪个线程优先执行；同一优先级，随机选择一个执行

package com.itheima.Thread;

//1.创建一个Thread类的子类
public class MyThread extends Thread {
    //	2、在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println("mythread:"+i);
        }

    }
}


package com.itheima.Thread;

public class MyThreadDemo01 {
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        MyThread mt=new MyThread();
        //4、调用Thread类中的方法start方法，开启新的线程，执行run方法
        mt.start();
        for (int i = 0; i <20 ; i++) {
            System.out.println("main:"+i);
        }

    }
}

多线程原理

多线程随机打印结果原理

JVM执行main方法，找os开辟一条main方法通向cpu的路径，这个路径叫main线程，主线程cpu通过这个线程，这个路径可以执行main方法。又因为创建了Thread类的子类对象，所以又开辟了一条通向cpu的新路径，用来执行run方法

image-20210707114639718

多线程内存图解

image-20210707115557700

即直接使用run方法和调用start方法还是有区别的。

直接调用run方法:那么run方法会进行压栈操作，和main方法在同一个栈内，这时就变成了单线程。

调用start方法：它会再开辟新的栈空间，然后执行run方法，实现了多线程。

创建多线程程序的第二种方式：实现Runnable接口

java.lang.Runnable ,Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run的无参数方法。

java.lang.Thread类的构造方法

Thread(Runnable target) 分配一个新的 Thread对象。
Thread(Runnable target, String name) 分配一个新的 Thread对象。

实现步骤

1、创建一个Runnable接口的实现类

2、在实现类中重写Runnable接口的run方法，设置线程任务

3、创建一个Runnable接口的实现类对象

4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象

5、调用Thread类中的start方法，开启新的线程执行run方法

package com.itheima.Thread;
/*1、创建一个Runnable接口的实现类

2、在实现类中重写Runnable接口的run方法，设置线程任务*/
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }

    }
}


package com.itheima.Thread;

public class MyRunnableDemo01 {
    public static void main(String[] args) {
        //*3、创建一个Runnable接口的实现类对象
        Runnable mr=new MyRunnable();
        //4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread th=new Thread(mr);
       // 5、调用Thread类中的start方法，开启新的线程执行run方法
        th.start();
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }

    }

}

Thread类

构造方法：

  • public Thread() :分配一个新的线程对象。

  • public Thread(String name) :分配一个指定名字的新的线程对象。

  • public Thread(Runnable target) :分配一个带有指定目标新的线程对象。

  • public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：

  • public String getName() :获取当前线程名称。

  • public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。

  • public void run() :此线程要执行的任务在此处定义代码。

  • public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

  • public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

package com.itheima_01;

public class MyThread extends Thread {
    @Override
    public void run() {
        //链式编程
        System.out.println(Thread.currentThread().getName());
    }
}


package com.itheima_01;

public class MyThreadDemo01 {
    public static void main(String[] args) {
        //创建Thread子类的对象
        MyThread mt=new MyThread();
        //调用start方法
        mt.start(); //Thread-0
        new MyThread().start(); //Thread-1
        //currentThread(),静态方法，所以可以直接类名.名称调用,返回对当前正在执行的线程对象的引用

        System.out.println(Thread.currentThread().getName()); //main

    }
}


package com.itheima_01;
/*
* public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。*/
public class SleepDemo {
    public static void main(String[] args) throws InterruptedException {
        //模拟秒表
        for (int i = 1; i <=60 ; i++) {
            System.out.println(i);
            //使用Tread类的sleep方法让程序睡眠一秒钟(1000毫秒)
            Thread.sleep(1000);
        }
    }
}

Thread和Runnable的区别

实现Runnable接口创建多线程程序的好处：

1、避免了单继承的局限性

​ 一个类只能继承一个类（一个人只能有一个亲爹），类继承了Thread类就不能继承其他的类

​ 实现了Runnable接口，还可以继承其他的类，实现其他的接口

2、增强了程序的扩展性，降低了程序的耦合性

​ 实现了Runnable接口的方式，把设置线程任务和开启新线程进行了分离

​ 分离：实现类中，重写了run方法：用来设置线程任务

​ 创建Thread类对象，调用start方法：用来开启新线程

匿名内部类方式实现线程的创建

匿名：没有名字。 内部类：写在其他类的内部

匿名内部类作用：简化代码

​ 把子类继承父类，重写父类的方法，创建子类对象合一步完成

​ 把实现类实现类接口，重写接口中的方法，创建实现类对象合一步完成

匿名内部类的最终产物：子类/实现类对象，而这个类没有名字

package com.itheima_01;

public class InnerClassThreadDemo {
    public static void main(String[] args) {
        //用Thread方法和匿名内部类创建线程
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+i);
                }
            }
        }.start();
        //用Runnable和匿名内部类实现创建线程
        //Runnable r=new RunnableImpl() 多态
        Runnable r=new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"小暑");
                }
            }
        };
        new Thread(r).start();
        //上面代码的简化
        new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"夏天");
                }
            }
        }).start();

    }
}

线程安全

概述：如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样

的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

通过一个案例，演示线程的安全问题：

电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个

(本场电影只能卖100张票)。 (多个窗口一起卖这100张票)

image-20210707150509903

用代码演示三个窗口买票引起的线程安全问题

package com.itheima_02;

public class RunnableImpl implements Runnable {
    private  int ticket=100;
    @Override
    public void run() {
        while(true){
            if(ticket>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }
}


package com.itheima_02;

public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnab的实现类对象
        RunnableImpl r=new RunnableImpl();
        //创建Thread的对象，并采用带参的构造方法
        //创建三个线程
        Thread t0=new Thread(r);
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}

发现程序出现了两个问题：

  1. 相同的票数,比如5这张票被卖了两回。

  2. 不存在的票，比如0票与-1票，是不存在的。

线程安全问题产生的原理

image-20210707152701916

解决线程安全问题：同步代码块

synchronized（['sɪŋkrənaɪzd]）

格式：

synchronized(锁对象){

​ 可能会出现线程安全问题的代码（访问了共享数据的代码）

}

注意：1、通过代码块中的锁对象，可以使用任意的对象

​ 2、但是必须保证多个线程使用的锁对象是同一个

​ 3、锁对象作用：把同步代码块锁住，只让一个线程在同步代码块中执行

package com.itheima.Safe;

/*
    卖票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全问题的一种方案:使用同步代码块
    格式:
        synchronized(锁对象){
            可能会出现线程安全问题的代码(访问了共享数据的代码)
        }

    注意:
        1.通过代码块中的锁对象, 
        2.但是必须保证多个线程使用的锁对象是同一个
        3.锁对象作用:
            把同步代码块锁住,只让一个线程在同步代码块中执行
 */
public class RunnableImpl1 implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            //同步代码块
            synchronized (obj){
                //先判断票是否存在
                if(ticket>0){
                    //提高安全问题出现的概率,让程序睡眠
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //票存在,卖票 ticket--
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                }
            }
        }
    }
}

同步技术的原理

image-20210707161215140

同步技术的原理：

使用一个锁对象，这个锁对象叫同步锁，也叫对象锁，也叫对象监视器

3个线程一起抢夺cpu的执行权，谁抢到了谁执行run方法进行卖票

t0抢到了cpu的执行权，执行run方法，遇到synchronized代码块，这是t0会检查synchronized代码块是否有对象，发现有，就会获取锁对象，进入到同步中执行

t1抢到了cpu的执行权，执行run方法，遇到synchronized代码块，这是t1会检查synchronized代码块是否有锁对象，发现没有，t1就会进入到阻塞状态，会一直等待t0线程归还锁对象。一直到t0线程执行完同步中的代码，会把锁对象归还给同步代码块，t1才能获取到锁对象进入到同步中执行

总结：同步中的线程，没有执行完毕不会释放锁，同步外的线程没有锁进不去同步

同步方法

是解决线程安全问题的第二种方法。

格式：

public synchronized void method(){

可能会产生线程安全问题的代码

}

同步锁是谁? 

对于非static方法,同步锁就是this。 

对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

使用步骤：1、把访问了共享数据的代码抽取出来，放到一个方法中

2、在方法上添加synchronized修饰符

同步方法也会把方法内部的代码锁住，只让一个线程执行。那么同步方法的锁对象是谁？就是实现类对象 new RunnableImpl() ，也就是this

package com.itheima.Synchronized;

public class RunnableImpl1 implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;


    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            payTicket();

        }
    }

    //定义一个同步方法
    public synchronized void payTicket(){
        //同步代码块
        /*synchronized (this){*/
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        /*}*/

    }
}

静态同步方法

静态同步方法的锁对象不能是this。因为this是创建对象之后产生的，静态方法优先于对象。静态方法的锁对象是本类的class属性-------》class文件对象（反射）

package com.itheima.StaticSynchronized;

public class RunnableImpl1 implements Runnable{
    //定义一个多个线程共享的票源
    private static int ticket = 100;


    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            payTicket();

        }
    }

    //定义一个同步方法
    public static synchronized void payTicket(){
        //同步代码块
        synchronized (RunnableImpl1.class){
            //先判断票是否存在
            if(ticket>0){//变量要定义成静态的，因为静态的访问静态的
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }

    }
}

Lock锁

是解决线程安全问题的第三种方法。

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,

同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

  • public void lock() :加同步锁。

  • public void unlock() :释放同步锁。

使用步骤：1、在成员位置创建一个ReentrantLock对象

​ 2、在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁

​ 3、在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁（通常将其放在finally里，即不管代码是否有异常，都会执行释放锁）

package com.itheima.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class RunnableImpl1 implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;
    //1、在成员位置创建一个ReentrantLock对象
    ReentrantLock L=new ReentrantLock();

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            //2、在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
            L.lock();
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                    //票存在,卖票 ticket--
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    L.unlock();
                }


            }

        }
    }


}
你好y
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java多线程-线程安全问题练习题
01-30
在Java多线程编程中，线程安全问题是非常关键的概念，它涉及到多个线程访问共享资源时可能出现的数据不一致或异常情况。...对于初学者来说，解决线程安全问题的练习题是提高这方面技能的有效途径。
Java多线程篇：多线程的基础、线程的创建和使用、线程安全问题、Java中锁的问题、高并发场景、线程的生命周期、死锁 DeadLock、线程的通信
weixin_51612062的博客
08-15 375
Java学习的第25、26天，Java多线程篇：多线程的基础、线程的创建和使用、线程安全问题、Java中锁的问题、高并发场景、线程的生命周期、死锁 DeadLock、线程的通信，超级详细！
解决多线程安全问题
weixin_55782195的博客
05-18 597
解决多线程安全问题的方案： 一、使用同步代码块 格式：synchronized(锁对象){ 可能出现线程安全问题的代码（访问了共享数据的代码） } 注意：线程中的锁对象，可以使用任意的对象 必须保证多个线程使用的锁对象是同一个 锁对象的作用：把同步代码块锁住，只让一个线程在同步代码块中执行 总结：同步中的线程，没有执行完毕不会释放锁，同步外的线程没有锁进不去同步 二、使用同步方法 步骤：把访问共享数据的代码抽取出来，放到一个方法中 在方法上添加synchronized修饰符 格式： 修饰符 synchron
创建多线程的两种方式（从使用到源码详解，内含高频面试题）
最新发布
2301_77615930的博客
05-13 761
创建多线程的两种方式（从使用到源码详解，内含高频面试题）
多线程安全问题以及解决方式
m0_51127483的博客
09-04 1956
因为每条语句执行都需要时间的，当某一线程抢占到CPU执行权时，便进入 run 方法执行到 if 语句，还没来得及对共享数据进行操作，就失去了CPU的执行权，被其他线程抢占。等再次获得CPU执行权并继续对共享数据进行操作时，可能此时共享数据已经不满足执行条件了，但是还得继续执行。这样就出现了安全问题。
java多线程之--(2)实现线程安全的三种方式
weixin_44232093的博客
01-10 1484
我们在开发中直接使用线程是无法保证线程安全的,有可能出现多个线程先后更改数据造成所得到的数据是脏数据,那么怎么解决这种问题呢,就要应用到线程安全的三种解决方法了 1. 线程安全 线程安全: 如果有多个线程在同时运行，而这些线程可能会同时运行某段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的 线程不安全: 当有多个线程在同时运行，这些线程同...
实现多线程安全的3种方式
热门推荐
jinggod的博客
10-18 3万+
1、先来了解一下：为什么多线程并发是不安全的？  在操作系统中，线程是不拥有资源的，进程是拥有资源的。而线程是由进程创建的，一个进程可以创建多个线程，这些线程共享着进程中的资源。所以，当线程一起并发运行时，同时对一个数据进行修改，就可能会造成数据的不一致性，看下面的例子： 假设一个简单的int字段被定义和初始化： int counter = 0; 该counter字段在两个线程A和B
Java多线程-解决单例模式中的懒汉式的线程安全问题
02-01
### Java多线程—解决单例模式中的懒汉式的线程安全问题 #### 一、单例设计模式的线程安全问题 ##### （1）饿汉式没有线程安全问题 **饿汉式**是一种非常典型的单例模式实现方式，其特点是在类加载时就完成了实例...
ArrayList源码和多线程安全问题分析
08-25
ArrayList 源码和多线程安全问题分析是一个复杂的问题，它需要我们对 Java 集合类和多线程编程有深入的理解。通过这篇文章，我们可以了解到 ArrayList 的内部结构和多线程安全问题，并学会如何解决这些问题。
完美解决Java中的线程安全问题
08-29
Java中线程安全问题的解决方案 Java 中的线程安全问题是一个常见的问题...今天，我们讨论了使用 synchronized 关键字来解决线程安全问题，但这只是解决线程安全问题的一种方法，还有其他方法和技术可以解决这个问题。
C++线程安全问题及解决方法，C++智能指针
11-30
能学到什么：了解C++线程安全问题的原因，以及掌握解决线程安全问题的方法。同时能够掌握一下锁的使用。能够了解C++智能指针的使用场景。阅读建议：能够详细阅读，同时配合整理的例子进行练习使用，能够快速的掌握...
创建多线程的四种方式
qq_31856061的博客
06-21 1201
注意：实现Runnable接口方式中，调用的不是Thread类的run()方法，而是在线程启动后，去调用Runnable类型的run()方法，也就是我们传入的实现类中的run()方法。就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题。是一个用链表实现的有界阻塞队列，在不设置的情况下，将是一个无边界的阻塞队列，最大长度为。创建线程池，主要是避免使用其中的默认实现，那么我们可以自己直接调用。的静态方法创建线程池时，用的是。
多线程会遇到的问题与解决方法
前后端分离，人不分离！
10-20 2661
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题。
线程安全问题的原因和解决方案
qq_55072036的博客
07-11 507
我们的预期是，当t2修改了flag的值之后，使flag不再为0，此时跳出循环，线程t1结束。这里我们也发现，说是保证原子性，不是让这里的三个操作一次执行完成，也不是这三步操作过程中不进行调度，而是让其他想操作的线程阻塞等待了。根据比较结果，来进行下一步的操作。总的来说，就是wait和notify规定了t1和t2线程的执行顺序，因此也就使t1和t2的执行有了顺序，解决了抢占式执行，随机调度。我们要注意的是，虽然我们的wait是阻塞在了synchronized代码块里了，但是实际上，这里的阻塞是释放了锁的。
线程安全问题的原因及解决方案
qq_64421953的博客
03-25 3284
线程安全问题：简单来说，就是在多线程的调度下，导致出现了一些随机性，随机性使代码出现 了一些bug =>线程不安全 造成线程不安全的原因有哪些呢？ 1）抢占式执行，调度过程随机（也是万恶之源，无法解决） 2）多个线程同时修改同一个变量（可以适当调整代码结构，避免这种情况） 3）针对变量的操作，不是原子的（加锁，synchronized) 4)内存可见性，一个线程频繁读，一个线程写（使用volatile） 5）指令重排序（使用synchronized) 解决方法： 1）使用synchro
创建多线程的四种方式 看完不懂，你来捶我！！！
m0_69901140的博客
04-01 1953
线程(thread)是一个程序内部的一条执行路径。我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径，程序中如果只有一条执行路径，那么这个程序就是单线程的程序。多线程是指从软硬件上实现多条执行流程的技术。
实现线程安全的四种方式
qq_37685457的博客
05-01 1万+
首先说说什么是线程安全性问题，多个线程共享同一个全局变量或静态变量，多个线程同时读数据不会发生数据安全性问题，但是有一个线程对数据进行写的时候，再有其他的线程来读写共享数据就有可能发生线程安全性问题。 线程安全性问题出现的三个必要条件： 1、多线程环境下 2、多个线程共享同一个资源 3、对资源进行非原子性操作 解决线程安全的四种方式： 1、synchronized锁（偏向锁，轻量级锁，...
为什么会有多线程？什么是线程安全？如何保证线程安全？（带详细例子）
超悦人生
01-14 5175
1. 为什么会有多线程？ 2. 什么是线程安全？3. 怎么样保证线程安全？
0 多线程之创建多线程的四种方式
weixin_44484668的博客
03-05 873
方式一：继承Thread类的方式： 创建一个继承于Thread类的子类 重写Thread类的run() --> 将此线程执行的操作声明在run()中 创建Thread类的子类的对象 通过此对象调用start()：start（）作用①启动当前线程 ② 调用当前线程的run() 输出100以内的偶数 //1. 创建一个继承于Thread类的子类 class MyThread extends Thread { // 2. 重写Thread类的run() --&gt
Java多线程：懒汉式单例线程安全解决方案
**解决线程安全问题的方式：** - **方式1：同步方法** (Double-Check Locking) - 在`getInstance()`方法中加锁，确保在单个线程中创建对象，然后检查对象是否存在，如果不存在则创建，否则直接返回。 ```java ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值