一、多线程两种实现方式：Thread类、Runnable接口、单例设计模式、线程安全、线程通信

最新推荐文章于 2024-06-06 08:30:00 发布
最新推荐文章于 2024-06-06 08:30:00 发布
阅读量416 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fasujbhf/article/details/108917356
版权

一、Thread类的构造器和方法们

1、构造器

Thread()

Tread(String name)

2、Thread类的方法：

（1）public void run (){}子类会重写它，它是线程完成任务的方法

（2）public void start() 重启线程的方法

（3）public String getName():获取线程名字

自定义线程的默认名称是： Thread -编号，修改名称可以调用setName(String name)或者是在创建线程是用构造器为name赋值

（4）public static Thread currentThread():获取当前线程对象

（5）public int getPriority():获取线程的优先级

public void setPriority(int)：获取线程的优先级

优先级：优先级越高，那么CPU调用它的概率越高。
优先级的范围：MIN_PRIORITY ~ MAX_PRIORITY范围内
MIN_PRIORITY：1
MAX_PRIORITY：10
NORM_PRIORITY：5

（6）public final boolean isAlive():判断线程是否还活着

public class TestThread {
    public static void main(String[] args) {
        MyThread my = new MyThread("线程1");
//        my.setPriority(100); //IllegalArgumentException非法参数异常
        my.start();

/*        MyThread my2 = new MyThread();
        my2.start();*/

        for(int i=2; i<=100; i+=2){
            System.out.println(Thread.currentThread().getName() + ":" + i);
            //因为这句代码是main线程执行的，那么Thread.currentThread()获取的就是main线程
        }
    }
}

class MyThread extends Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for(int i=1; i<=100; i+=2){
            System.out.println(getName() + ":" + i);//getName()从Thread父类继承的
        }
    }
}
3、Thread类的方法：

（7）public static void sleep(long millis):线程休眠，单位是毫秒

public static void sleep(long millis,int nanos):线程休眠单位是毫秒和纳秒

（8）public static void yield():暂时当前正在执行的线程对象，并执行其他线程

yield()只是说当前线程象征性的谦让一下，不代表CPU一定会让给其他人。

（9）public void join():加塞

public void join(时间):制定加塞时间

（10）public final void stop():停止线程，已过时

public class TestThread2 {
    public static void main(String[] args) throws InterruptedException {
/*        for(int i=10; i>0; i--){
            System.out.println(i);
            Thread.sleep(1000);
//            TimeUnit.SECONDS.sleep(1);
//            TimeUnit.MINUTES.sleep(1);
        }*/

        TheadDemo demo = new TheadDemo();
        demo.start();

        TheadDemo demo2 = new TheadDemo();
        demo2.start();


        for (int i=11; i<=20; i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
            if(i==11){
//                Thread.yield();
                //demo.join(); //demo线程不结束，当前线程main就没机会了   demo把main线程阻塞了
                            //demo和demo2不会出现阻塞现象，还是互抢CPU
                demo.join(5);//5毫秒之后，main就自由了
            }
        }
    }
}

class TheadDemo extends Thread{
    public void run(){
        for(int i=1; i<=10; i++){
            System.out.println(getName() + ":" + i);
        }
    }
}
4、守护线程

（1）角色1：干正事的线程

（2）角色2：服务于角色1的线程，称为守护线程

（3）语法格式

Thread类中有一个方法：public final void setDaemon(boolean on) 如果为 true，则将该线程标记为守护线程

二、线程安全问题

1什么是线程安全问题？

当多个线程“同时”使用同一个“共享”数据时，可能就会有线程安全问题。
如果一些线程进行“读/查看”操作，一些线程进行“写/修饰”操作，这个才会出现线程安全问题。
如果所有线程都是进行的“读”操作，那么是不会有线程安全问题的。

共享数据可以是同一个变量或同一个文件或同一个表中的同一条记录等。

知识点：哪些内存是线程之间可以共享的，哪些内存是线程之间独立的。

2.JVM的内存：

（1）方法区
（2）堆
（3）栈（包括虚拟机栈和本地方法栈）
（4）程序计数器：CPU在多个线程之间切换时，程序计数器就要记录每一个线程当前执行到哪里，下一条指令是什么。

其中（3）（4）一定是线程独立。
（1）和（2）是多个线程可以共享的。但是如果是堆的话，必须保证是同一个对象。

3、如何解决

加锁

在SE阶段，使用的是同步锁（synchronized）

在高级阶段，使用的Lock锁（juc:java.util.concurrent ）

语法：

（1）同步代码块

（2）同步方法

4、同步代码快

语法格式：

synchronized(锁对象){

需要加锁的代码}

要加在循环里边，判断条件外边

要求：
（1）锁对象可以是任意类型的对象，但是必须要求多个线程使用同一个锁对象
（2）锁的范围太大了不行，太小也不行

一般考虑单次任务设计的代码有哪些？
比如卖票，单次任务
①条件判断是否有票
②票数减少
③查看剩余票
 */
public class TestSafe1 {
    public static void main(String[] args) {
        Window w1 =new Window("窗口一");
        Window w2 =new Window("窗口二");
        Window w3 =new Window("窗口三");
        //每个窗口卖出了10张票

        w1.start();
        w2.start();
        w3.start();
    }

    //这里声明为静态成员内部类是为了避免重名问题，在同一个包中
    static class Window extends Thread{
        public Window(String name) {
            super(name);
        }

        public void run(){
            int total = 10;//局部变量存储在栈中
            while(total>0){
                total--;
                System.out.println(getName() + "卖出一张票，剩余" +total + "张");
            }
        }
    }
}
5、同步方法

语法格式：

【其他修饰符】synchronized 返回值类型 方法名（【形参列表】）【throws 异常列表】{

}

要求：

（1）锁对象，多个线程必须是同一个锁对象

非静态方法锁对象，是this

静态方法，锁对象，是当前类的class对象

（2）范围

举例：卖票
实际开发中，一般写多线程的程序是怎么写？
（1）先写一个资源类，例如：票
（2）创建资源类的对象
（3）其他多个线程使用资源类的对象

public class TestSynchronizedMethod1 {
    public static void main(String[] args) {
        //创建资源类的对象
        Ticket ticket = new Ticket();

        new Thread("窗口一"){
            public void run(){
                while(ticket.getTotal()>0){
                    ticket.sale();
                }
            }
        }.start();

        new Thread("窗口二"){
            public void run(){
                while(ticket.getTotal()>0){
                    ticket.sale();
                }
            }
        }.start();


        new Thread("窗口三"){
            public void run(){
                while(ticket.getTotal()>0){
                    ticket.sale();
                }
            }
        }.start();


    }

    //资源类
    static class Ticket{
        private int total = 1000;//总票数

        //调用一次sale方法，卖一张票
        //非静态方法，锁对象是this，这里的this是同一个对象
        public synchronized void sale(){
            if(total>0) {//双重保险
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                total--;
                System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余：" + total);
            }
        }

        public int getTotal() {
            return total;
        }
    }
}
6、单列设计模式

1、什么是设计模式：

解决某一类问题，前人给我们总结出来的代码模板，套路。
设计模式不是Java语言独有的，是适用于所有的开发语言。
一共有23种目前公认比较经典的设计模式。

2、单列设计模式

适用常见：如果你的系统/软件中，某一个类的对象要求在整个系统中只能出现一个。那么这个时候，这个类就应该用单例设计模式去设计。
比如：
（1）军事系统，总司令对象只有一个
（2）手机系统：时钟对象只有一个
（3）JavaEE系统

web服务器tomcat容器的容器对象，对于每一个Web项目来说只有一个。
spring框架，它的总的管理器对象只有一个。
…3、如何实现单例设计模式
（1）饿（恶）汉式单例设计模式
无论你什么时候用到这个对象，只要用到这个类了，就上来先创建这个类的唯一对象。“着急”，在类初始化时就创建了对象。
饥不择食

提前创建了，后面用的时候，直接用了，就快。
前慢后快。

（2）懒汉式单例设计模式
只有你真的需要这个类的对象了，我才不得已给你创建它，你不用我就先不给你创建。

懒这个设计在后面很多地方也都有用到，例如：后面会提到的懒加载等，延迟初始化等。
因为内存，性能都非常宝贵，如果你不用，确把相关的对象弄出来了，占着内存，消耗性能。

前快后用的时慢。

public class TestSingleton {
    @Test
    public void test01(){
        //获取Hungry1的唯一对象
        Hungry1 obj1 = Hungry1.INSTANCE;
        Hungry1 obj2 = Hungry1.INSTANCE;
        System.out.println(obj1 == obj2);
    }

    @Test
    public void test02(){
        //获取Hungry2的唯一对象
        Hungry2 obj1 = Hungry2.INSTANCE;
        Hungry2 obj2 = Hungry2.INSTANCE;
        System.out.println(obj1 == obj2);
    }

    @Test
    public void test03(){
        //获取Hungry2的唯一对象
        Hungry3 obj1 = Hungry3.getINSTANCE();
        Hungry3 obj2 = Hungry3.getINSTANCE();
        System.out.println(obj1 == obj2);
    }

    @Test
    public void test04(){
        Runtime currentRuntime = Runtime.getRuntime();//获取唯一的对象
        System.out.println("总内存：" + currentRuntime.totalMemory());
        System.out.println("空闲内存：" + currentRuntime.freeMemory());
    }

    @Test
    public void test05(){
        Lazy1 obj1 = Lazy1.getInstance();
        Lazy1 obj2 = Lazy1.getInstance();
        System.out.println(obj1 == obj2);
    }

    //多线程环境
    Lazy1 obj1;
    Lazy1 obj2;
    @Test
    public void test06(){
        Thread t1 = new Thread() {
            public void run() {
                obj1 = Lazy1.getInstance();
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                obj2 = Lazy1.getInstance();
            }
        };

        t1.start();
        t2.start();

        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(obj1);
        System.out.println(obj2);
        System.out.println(obj1 == obj2);
    }

    @Test
    public void test07(){
//        Lazy3.method();
        Lazy3 obj = Lazy3.getInstance();
    }
}

//饿汉式的写法（一）
class Hungry1{
    //(2)用一个静态的常量保存这个类对象
    public static final Hungry1 INSTANCE = new Hungry1();

    //(1)构造器私有化
    private Hungry1(){}
}

//饿汉式的写法（二）
enum Hungry2{
    INSTANCE
}

//饿汉式的写法（三），例如系统类中就有一个这样的代表 Runtime
//java.lang.Runtime：表示当前JVM的运行时环境对象
class Hungry3{
    //(2)用一个静态的常量保存这个类对象
    private static final Hungry3 INSTANCE = new Hungry3();

    //(1)构造器私有化
    private Hungry3(){}

    //（3）提供get方法
    public static Hungry3 getINSTANCE() {
        return INSTANCE;
    }
}

//懒汉式的写法（一）
class Lazy1{
    private static Lazy1 instance;
    //(1)构造器私有化
    private Lazy1(){}

    //(2)获取唯一对象的方法
/*    public static Lazy1 getInstance(){
        return new Lazy1();//错误，每次调用都new新的
    }*/
    public synchronized static Lazy1 getInstance(){
        if(instance == null){
            instance = new Lazy1();
        }
        return instance;
    }
}

//在Lazy1的基础上，进行优化
class Lazy2{
    private static Lazy2 instance;
    //(1)构造器私有化
    private Lazy2(){}

    //(2)获取唯一对象的方法
    public static Lazy2 getInstance(){
        if(instance == null) {//提高效率
            synchronized (Lazy2.class) {//Lazy2.class是得到当前类的Class对象
                if (instance == null) {//安全
                    instance = new Lazy2();
                }
            }
        }
        return instance;
    }
}

//提出了一种新的写法
class Lazy3{

    /*static{
        System.out.println("外部类的静态代码块");
    }*/

    //(1)构造器私有化
    private Lazy3(){}

    //静态内部类
    /*
    静态内部类的加载不会随着外部类的加载而加载
    静态内部类也是第一次使用它时加载
     */
    static class Inner{
        private static final Lazy3 INSTANCE = new Lazy3();

        /*static{
            System.out.println("内部类的静态代码块");
        }*/
    }

    public static Lazy3 getInstance(){
        return Inner.INSTANCE;
    }

   /* public static void method(){
        System.out.println("外部类的静态方法");
    }*/
}
7、线程通信

用于解决生产者与消费者问题
1、生产者与消费者问题

当有多个线程一起工作，一些线程是往“数据缓冲区”添加数据，称为生产者，一些线程是从“数据缓冲区”取/消耗数据，称为消费者。
此时，因为我们的“数据缓冲区”是有限的，那么当“数据缓冲区”满的时候，生产者线程应该“停”下来，等消费者消耗了数据之后，它再接着生产。
同理，当“数据缓冲区”空的时候，消费者线程应该“停”下来，等生产者生产了新的数据之后，它再接着消费。

两个问题：
（1）线程安全问题
多个线程，共享数据，有读有写操作
说明一定会用到synchronized或Lock

（2）线程的通信问题–>等待与唤醒问题

2、如何实现线程的等待与唤醒呢？
（1）wait(),wait(时间)：线程等待
（2）notify()/notifyAll()：线程唤醒/通知

notify()：只会唤醒1个
notifyAll()：唤醒所有等待的，被唤醒的如果需要接着wait，如果条件不成立，就可以干活了

要求：
wait和notify方法必须由“锁”对象调用，否则就报IllegalMonitorStateException异常。

3、举例
小饭馆，厨房与前厅之间有个小窗口，小窗口上有个小平台，上面最多可以放10盘菜。
现在饭馆营业。
开发：厨师
翠花：服务员
数据缓冲区：窗口的小平台
共享数据：菜

public class TestCommunicate {
    public static void main(String[] args) {
        Workbench workbench = new Workbench();
        Cook cook = new Cook("开发",workbench);
        Waiter waiter = new Waiter("翠花",workbench);
        cook.start();
        waiter.start();
    }
}
class Cook extends Thread{
    private  Workbench workbench;

    public Cook(String name, Workbench workbench) {
        super(name);
        this.workbench = workbench;
    }

    public void run(){
        while(true) {
            workbench.put();
        }
    }
}
class Waiter extends Thread{
    private  Workbench workbench;

    public Waiter(String name, Workbench workbench) {
        super(name);
        this.workbench = workbench;
    }

    public void run(){
        while(true) {
            workbench.take();
        }
    }
}

//资源类
class Workbench{
    private static final int MAX = 10;
    private int total;

    //厨师调用
    public synchronized void put(){ //非静态方法的锁对象，默认是this
        if(total >= MAX){
            try {
                //当前线程停下来
                this.wait();//this是当前线程的锁对象，即监视器对象
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        total++;
        System.out.println(Thread.currentThread().getName() + "做好了一盘菜，现在有：" + total);
        this.notify();
    }

    //服务员调用
    public synchronized void take(){
        if(total <= 0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        total--;
        System.out.println(Thread.currentThread().getName() + "取走了一盘菜，现在有：" + total);
        this.notify();
    }
}

三、关键字

1.volatile：

是告诉系统不要缓存这个变量

2，interrupt方法

是让休眠的线程停止休眠

五、进程时间

语法格式：

long 变量 = System.currentTimeMillis();

public class TestSystem {
    public static void main(String[] args) {
        long timeMillis = System.currentTimeMillis();
        System.out.println(timeMillis);//1599620217594
        /*
        1599620217594值是当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）。
        1599620265190值是当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）。
         */
    }
}
变成巨人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程下的单例模式
Morgan_Xiang的专栏
06-07 345
        单例模式就不在这里详细介绍了，这里要了解的是如何使单例模式遇到多线程是安全的。        单例模式分为饿汉模式和懒汉模式。        饿汉模式就类在加载的时候就创建实例，当使用类的时候已经将对象创建好了 public class SingletonMode1 { private static SingletonMode1 singletonMode1 = new ...
二、多线程学习笔记（实现多线程的四种方式和解决线程安全问题的三种方法）
陈大大的博客
08-27 494
一、理解程序、进程和线程的含义        1.程序：为完成某种特定任务而用某种语言编写的一组指令的集合，是一段静态的代码。        2.进程：是程序的一次执行过程，或是正在运行的一个程序，有自身的产生、存在和消亡的过程，即存在生命周期。        3.线程：进程进一步细化为线程，是一个程
多线程学习 实现多线程的两种方式 一
taiguolaotu的博客
07-25 139
实现多线程两种方式 一 继承Thread类 二 实现Runnable接口 因为Thread类已经实现了Runnable接口， 所以两者本质都是实现Runnable接口，并且实现Runnable接口中的run方法. 下面写了一个小例子，直接上代码。 public class TestThread { public static void main(String[] args) { /* Thread thread = new Thread(); //创建一个线程对象
Java基础教程 - 11 多线程
最新发布
山石岐渡的博客
06-06 755
在计算机中，进程是指正在执行中的一个程序，它由程序、数据和进程控制块组成。每个进程都有独立的地址空间，相互之间不能直接访问，是操作系统对程序运行进行管理的单位，每个进程都可以拥有多个线程。线程是指一条执行路径，它是进程中的一部分，可以与其他线程共享进程的资源和内存。线程是轻量级的进程，它比进程更快速，更容易创建和销毁。
线程Thread与Runnable接口
haoyuegongzi的博客
11-21 2809
之前一直是懵懂的使用Thread，对这个并没有太完整的概念。最近看了一些资料并在小项目中使用到了一些相关技术，现结合实际应用与查阅到的资料，聊着总结。一、首先，线程和线程类的区别：线程是硬件资源CPU调度任务执行的最小单元，是一个抽象的概念；线程类本质上就是一串可执行的代码，在Java中就是Thread.class文件。 Thread线程的定义如下public class Thread extend
多线程的实现方式及其区别
weixin_30315723的博客
05-09 312
实现多线程有两种方式：(自JDK1.5之后有三种，最后一种并不常用) 　　1.继承Thread类 　　2.实现Runnable接口（Callable接口） 一个类如果实现了Runnable接口或者继承了Thread类，那么它就是一个多线程类，如果是要实现多线程，还需要重写run()方法，所以run() 方法是多线程的入口。 但是在启动多线程的时候，不是从run()方法开始的...
Java多线程-创建多线程的基本方式二：实现Runnable接口
01-25
本文将详细讲解如何通过实现`Runnable`接口创建多线程，以及这种方式相较于继承`Thread`类的优势。 一、实现Runnable接口创建多线程 1. **步骤** 当一个类需要继承其他类而不能直接继承`Thread`类时，可以选择...
java实现多线程的两种方式继承Thread类和实现Runnable接口的方法
09-01
在Java中，创建多线程有两种主要的方式：继承`Thread`类和实现`Runnable`接口。这两种方式都是为了实现程序的并发执行，即允许多个任务在同一时间片内交替执行。下面我们将详细讨论这两种方法及其区别。 ### 继承...
Java多线程-创建多线程的基本方式一：继承Thread类
01-19
Java提供了多种创建多线程的方式，其中最基础的一种是通过继承Thread类来实现。 一、创建和启动线程 1. 概述 Java虚拟机（JVM）支持多线程执行，每个线程都是通过`java.lang.Thread`类的实例来表示的。创建一个...
Java有两种实现多线程的方式：通过Runnable接口、通过Thread直接实现，请掌握这两种实现方式，并编写示例程序。
04-23
1、Java有两种实现多线程的方式：通过Runnable接口、通过Thread直接实现，请掌握这两种实现方式，并编写示例程序。 2、多线程是并发执行的，交替占有cpu执行，请编写示例程序，并观察输出结果。 3、采用线程同步方法...
Java多线程-对比创建多线程的两种方式
01-25
Java多线程编程中，创建线程主要有两种方式：继承`Thread`类和实现`Runnable`接口。这两种方式虽然都能实现多线程，但它们在实际应用中有着不同的特性和适用场景。 首先，我们来看看继承`Thread`类的方式。这种方式...
getpriority 方法 java_int getPriority()
weixin_26833139的博客
02-19 461
int getPriority()描述 (Description)java.lang.Thread.getPriority()方法返回此线程的优先级。声明 (Declaration)以下是java.lang.Thread.getPriority()方法的声明public final int getPriority()参数 (Parameters)NA返回值 (Return Value)此方法返回此...
什么是多线程? 了解多线程的实现方式 线程方法 及线程安全问题
m0_68979682的博客
07-27 522
是指从软件或者硬件上实现多个线程并发执行的技术具有多线程能力的计算机因为有硬件的支持而能够在同一时间执行多个线程,提高性能并发和并行并行同一个时刻,多个指令在多个cpu上并发同一个时刻,多个指令在一个cpu上进程和线程什么是进程进程正在运行的软件>独立性进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位>动态性进程的实质是程序的一次执行过程,进程是动态产生,动态消亡的>并发性任何进程都可以同其他进程一起并发执行...
多线程详解Java三种实现方式+线程安全问题+死锁问题+线程池
qq_48783543的博客
09-26 523
继承Thread类实现多线程 1、run方法（需要重写） （1）：run方法就是线程要执行任务的方法 （2）：启动线程不需要调用run方法，而是调用threa里的start方法来启动任务 （3）：main方法中的叫做主线程，它和其他线程同时执行，其中谁先执行，谁后执行是不一定的（两个线程强占时间分配）看例子： package Day1; public class Demo1 { public static void main(String[] args) { MyThread myT
详解：Java多线程（主要内容：四种创建方式、线程安全问题、线程通讯、线程的生命周期以及线程池）
XMZHSY的博客
09-20 476
目录 一、Java多线程的四种创建方式 继承Thread类 实现Runnable接口 实现Callable接口 使用线程池 二、解决线程安全的三种方式 同步代码块 同步方法 Lock锁 三、有关线程的知识补给站 一、Java多线程的四种创建方式 继承Thread类 继承Thread类的操作步骤： 创建一个继承于Thread类的子类 重写Thread类的run()方法 --> 将此线程执行的操作声明在run()中 创建Thread类的子类的对象 通过此对象调用s.
Thread 、Runnable 简单实例
weixin_39795146的博客
08-03 424
直接上代码：有相应的说明 package Thread; /** * 继承Thread类，重写该类的run()方法。 */ public class myThread extends Thread { public void run() { //在run方法中可以执行一些需要线程处理的问题 //例如自己写的服务器、监听器等等 while(true)...
Thread 中用到的两种设计模式
【欢迎关注公众号：冬瓜白】
12-02 3031
其实有时候不能简单说哪种设计用到了哪些设计模式，设计模式本身就是对很多代码设计经验的总结。 模板模式 模板模式的应用就比较好理解了。在创建线程一般使用构建 Thread 类或者实现 Runnable 接口（这种说法是错误的，最起码是不严谨的，在 JDK 中代表线程的就只有 Thread 这个类，线程的执行单元就是 run() 方法，你可以通过继承 Thread 然后重写 run() 方法实现自...
java多个线程执行不同的函数_java多线程中执行多个程序的实例分析
weixin_42516710的博客
02-27 1024
免费资源网 - https://freexyz.cn/我们知道多线程因为同时处理子线程的能力，对于程序运行来说，能够达到很高的效率。不过很多人对于多线程的执行方法还没有尝试过，本篇我们将为大家介绍创建线程的方法，在这个基础上，对程序执行多条命令的方法进行展示。下面我们就来看看具体的操作步骤吧。1、创建线程对象我们需要用到Thread类，该类是java.lang包下的一个类，所以调用时不需要导入包。...
Java线程安全的三中方式
nightglow的博客
12-20 318
一个程序在运行起来的时候会转换成进程，通常含有多个线程。 通常情况下，一个进程中的比较耗时的操作（如长循环、文件上传下载、网络资源获取等），往往会采用多线程来解决。 比如显示生活中，银行取钱问题、火车票多个售票窗口的问题，通常会涉及到并发的问题，从而需要多线程的技术。 当进程中有多个并发线程进入一个重要数据的代码块时，在修改数据的过程中，很有可能引发线程安全问题，从而造成数据异常。例如，正常逻辑下...
Java特别篇-关于线程创建的三种方式的总结对比
02-04
Java特别篇深入探讨了线程创建的三种主要方式：继承Thread类、实现Runnable接口以及使用Callable和Future接口。本文将对这三种创建线程的方式进行详细解释和对比。 1. **继承Thread类**： - 创建步骤： - 创建一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值