Thread API的详细介绍

最新推荐文章于 2024-09-04 15:29:36 发布
最新推荐文章于 2024-09-04 15:29:36 发布
阅读量84 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/junjie2019/p/10585451.html
版权 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

import static java.util.stream.Collectors.toList;

public class Test {
    public static void main(String[] args){
//        ThradSleep.test();
//        ThreadPriority.test();
//        ThreadPriority.test();
//        ThreadId.test();
//        CurrentThread.test();
//        ThreadInterrupt.test();
//        ThreadIsInterrupted.test();
//        ThreadIsInterrupted2.test();
//        ThreadInterrupted.test();
//        ThreadTest.test();
//        ThreadJoin.test();
//        FightQueryExample.test();
        FlagThreadExit.test();`
    }
}

/*
    3.1.1 sleep方法介绍

        public static void sleep(long millis) throws InterruptedException
        public static void sleep(long millis, int nanos) throws InterruptedException

    3.1.2 使用TimeUnit代替Thread.sleep

        TimeUnit可以省去换算的步骤，比如线程想休眠3小时24分17秒88毫秒：
            TimeUnit.HOURS.sleep(3);
            TimeUnit.MINUTES.sleep(3);
            TimeUnit.SECONDS.sleep(3);
            TimeUnit.MILLISECONDS.sleep(3);

            ——我是真的需要把Java枚举部分看一下了。。。
 */
class ThradSleep{
    public static void test(){
        new Thread(()->{
            long startTime=System.currentTimeMillis();
            sleep(2_000L);
            long endTime=System.currentTimeMillis();
            System.out.println("Total: "+(endTime-startTime));
        }).start();
        long startTime=System.currentTimeMillis();
        sleep(3_000L);
        long endTime=System.currentTimeMillis();
        System.out.println("Main Total: "+(endTime-startTime));
    }

    private static void sleep(long ms){
        try{
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/*
    3.2.1 yield方法介绍

    调用yield方法会使当前线程从RUNNING状态切换到RUNNABLE状态，这个方法一般不常用

        ——Java8的流和Lam，早看早练习，稳赚不赔！！！


    3.2.2 yield和sleep

    其本质区别：
        1.sleep会导致当前线程暂停指定的之间，没有CPU时间片的消耗。（这个CPU时间片消耗指的是什么？）
        2.yield只是对CPU调度器的一个暗示，可能导致线程上下文的切换。

        3.sleep会使线程短暂block，会在指定的时间内释放CPU资源
        4.yield会使RUNNING状态的Thread进入RUNABLE状态

        5.sleep几乎会百分百地完成指定时间的休眠，而yield的提示并不一定有用

        6.一个线程内调用了sleep，另一个线程调用了interrupt，这个调用了sleep的线程会捕获到
        中断信号，而yield不会。
 */
class ThreadYield{
    public static void test() {
        IntStream.range(0,2).mapToObj(ThreadYield::create)
                .forEach(Thread::start);
    }

    private static Thread create(int index) {
        return new Thread(()->{
            if (index == 0) {
                Thread.yield();
            }
            System.out.println(index);
        });
    }
}

/*
    3.3 设置线程优先级

        public final void setPriority(int newPriority); ：为线程设定优先级
        public final int getPriority();                 ：获得线程的优先级

    3.3.2 线程优先级源码分析

    要点：
        1.线程的优先级不能小于1，不能大于10；
        2.如果优先级大于group的优先级，则优先级会被设置为group的优先级；
 */
class ThreadPriority{
    public static void test(){
        /* 实验设置优先级
        Thread t1 = new Thread(()->{
            while(true){
                System.out.println("t1");
            }
        });

        Thread t2 = new Thread(()->{
            while(true){
                System.out.println("t1");
            }
        });

        t1.setPriority(3);
        t2.setPriority(10);

        t1.start();
        t2.start();
        */

        /* 实验线程优先级和组优先级关系
        ThreadGroup group = new ThreadGroup("test");
        group.setMaxPriority(7);

        Thread t = new Thread(group,"test-thread");
        t.setPriority(10);
        System.out.println("t.getPriority():"+t.getPriority());
        */

        /* 实验线程默认优先级 */
        Thread t1 = new Thread();
        System.out.println("t1 priority:"+t1.getPriority());

        Thread t2 = new Thread(()->{
            Thread t3 = new Thread();
            System.out.println("t3 priority:"+t3.getPriority());
        });
        t2.setPriority(6);


        t2.start();
        System.out.println("t2 priority:"+t2.getPriority());
    }
}

/*
    3.4 获取线程ID

        public long getId();
 */
class ThreadId{
    public static void test(){
        System.out.println("main id: "+Thread.currentThread().getId());

        Thread t = new Thread("test");

        System.out.println("t id: "+t.getId());

    }
}

/*
    3.5 获取当前线程

        public static Thread currentThread();
 */
class CurrentThread{
    public static void test(){
        Thread t = new Thread() {
            public void run() {
                System.out.println(Thread.currentThread() == this);
            }
        };
        t.start();

        String name = Thread.currentThread().getName();
        System.out.println("main".equals(name));
    }
}

/*
    3.6 设置线程上下文类加载器

        public ClassLoader getContextClassLoader()        :获取
        public void setContextClassLoader(ClassLoader cl) :设置
 */

/*
 *************************************************************************
 *************************************************************************
 *************************************************************************
 *************************************************************************
 */

/*
    3.7 线程interrupt

        public void interrupt()
        public static boolean interrupted()
        public boolean isInterrupted()

        ——标记一下，我对interrupted()方法有点疑惑，这个方法是怎么办到把我一个
            对象的标识位给复原了的。额，很尴尬，它调用了一个currentThread方法，
            然后间接的设置了这个标志位，也就说明这个方法只能在某个Thread内部调用。

    3.7.1 interrupt

    如下方法的调用会使得当前线程进入阻塞状态：
        1.Object的wait(),wait(long),wait(long,int)
        2.Thread的sleep(long),sleep(long,int)
        3.Thread的join,join(long),join(long,int)
        4.InterruptibleChannel的io操作（这个很陌生！！！）
        5.Selector的wakeup方法（这个很陌生！！！）
        6.其他方法

    如果另外一个线程调用阻塞线程的interrupt方法，则会打断这种阻塞，因此这种方法有时
    会被称为可中断方法。打断一个线程并不等于该线程的生命周期的结束，仅仅是打断了当前
    线程的阻塞状态。一旦线程在阻塞情况下被打断了，都会抛出一个称为InterruptedException
    的异常，这个异常就像一个signal一样，高诉这个刚刚被中断的线程，哦，我刚刚是因为
    中断被唤醒的啊~~~


    要点：
        interrupt()方法到底做了什么？在一个线程内部存在一个名为interrupt flag的标识
        如果一个线程被interrupt，那么它的flag将会被设置。如果当前线程只在执行可中断的
        方法，且被阻塞时，调用interrupt方法将其中断，反而会导致flag被清除~~~（什么乱
        七八糟啊啊啊啊）
 */
class ThreadInterrupt{
    public static void test(){
        Thread t = new Thread(()->{
            try{
                TimeUnit.MINUTES.sleep(1);
            } catch (InterruptedException e) {
                System.out.println("Oh,i am be interrupted...");
            }
        });
        t.start();
        try {
            TimeUnit.MILLISECONDS.sleep(2);
            t.interrupt(); //去叫醒这个兄弟！！！
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/*
    3.7.2 isInterrupted

    isInterrupted是Thread的一个成员方法，它主要判断当前线程是否被中断，该方法仅仅是对
    interrupt标识的一个判断，并不会影响标识发生任何改变。
        ——我感觉作者没有把阻塞和中断的许多细节给讲清楚
 */
class ThreadIsInterrupted{
    public static void test(){
        Thread t = new Thread(){
            @Override
            public void run() {
                while(true){
                    //这个地方真的能被中断么？？？
                    //do nothing
                }
            }
        };

        t.start();
        try {
            TimeUnit.MILLISECONDS.sleep(2);
            System.out.printf("Thread is interrupted? %s",t.isInterrupted());
            t.interrupt();
            System.out.printf("Thread is interrupted? %s",t.isInterrupted());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadIsInterrupted2{
    public static void test(){
        Thread t = new Thread(){
            @Override
            public void run() {
                while(true){
                    try{
                        TimeUnit.MINUTES.sleep(1);
                    } catch (InterruptedException e) {
                        System.out.printf("I am be interrupted? %s\n",isInterrupted());
                    }
                }
            }
        };

        t.start();
        try {
            TimeUnit.MILLISECONDS.sleep(2);
            System.out.printf("Thread is interrupted? %s \n",t.isInterrupted());
            t.interrupt();
            System.out.printf("Thread is interrupted? %s \n",t.isInterrupted());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/*
===========================================================================
                            实验总结
===========================================================================
实验结果分析：
    1.调用interrupt这个方法了，这个方法只是简简单单的设置了一个flag
    2.调用了isInterrupted这个方法了，也只是简简单单的去访问一下这个flag
    3.线程中如果没有正在阻塞的方法， 你调用了interrupt是没有任何意义的，你设置的
        这个flag根本没有方法去访问
    4.如果线程正在某个方法上阻塞这，那么这个线程被分到时间片时，肯定先检查一下
        这个flag的值，如果这个flag的值代表中断发生了，就让这个阻塞的方法返回
        ，同时将这个flag复原。
===========================================================================
 */

/*
    3.7.3 interrupted

    interrupted是一个静态方法，调用这个方法会擦除线程的interrupt表示，需要注意
    的是，如果线程被打断了，那么第一次调用interrupted方法会返回true，并且立即擦
    除interrupt标识~~~
        ——我想知道的是，这个东西有什么用！！！
 */
class ThreadInterrupted{
    public static void test() {
        Thread t = new Thread(){
            @Override
            public void run() {
                while (true) {
                    /*
                        我有点不懂这个地方？？？，你调用的是一个
                        静态方法，来消除的是一个对象的标识。。。
                     */
                    System.out.println(Thread.interrupted());
                }
            }
        };
        t.setDaemon(true);
        t.start();

        try {
            TimeUnit.MILLISECONDS.sleep(2);
            t.interrupted();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/*
    3.7.4 interrupt注意事项

        如果一个线程设置了interrupt标识，那么接下来的可中断方法会立即中断~~~
            ——不然会造成中断信号丢失，问题更大
 */
class ThreadTest{
    public static void test() {
        System.out.println("Main thread is interrupted:"+Thread.interrupted());
        Thread.currentThread().interrupt();
        System.out.println("Main thread is interrupted now?"+Thread.currentThread().isInterrupted());

        try{
            TimeUnit.MINUTES.sleep(1);
        } catch (InterruptedException e) {
            System.out.println("I will be interrupted still.");
        }

    }
}

/*
    3.8 线程join

        public final void join() throws InterruptException
        public final synchronized void join(long millis, int nanos) throws InterruptException
        public final synchronized void join(long millis) throws InterruptException

    3.8.1 线程join方法详解

    有两种调用join的方法，main线程创建了A线程对象，然后调用A的join方法，这时候main线程会
    等待A线程完成，然后在执行。还有一种就是在A线程内部的run方法中，调用了自生的join方法，不
    知道在这种情况下会发生什么事情。
 */
class ThreadJoin{
    public static void test() {
        List<Thread> threads = IntStream.range(1,3)
                .mapToObj(ThreadJoin::create)
                .collect(toList());

        threads.forEach(Thread::start);

        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"#"+i);
            shortSleep();
        }
    }

    private static Thread create(int seq) {
        return new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+"#"+i);
            }
        },String.valueOf(seq));
    }

    private static void shortSleep() {
        try{
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/*
    3.8.2 join方法结合实战

    需求：
        如果你有一个APP，主要用于查询航班信息，你的APP是没有这些实时数据的，当用户发起查询
        请求时，你需要到各大航空公司的接口获取信息，最后同意整理加工返回到APP客户端。当然
        JDK自带了很多高级工具，比如CountDownLatch和CyclieBarrier等都可以完成类似的功能，

        该例子是典型的串行任务局部并行化处理~~~用户在APP客户端输入出发地北京和目的地上海后，
        服务端接受到这个请求之后，先来验证用户的信息，然后到各大航空公司的接口查询信息，最后
        经过整理加工返回给客户端，每一个航空公司的接口不会都一样，获取数据格式也不一样，查询
        的速度也存在差异，如果再更航空公司进行串行化交互（逐个地查询），很明显客户端需要等待
        很长的时间，这样的话，用户体验就会非常差。如果我们将每个航空公司的查询都交给一个线程
        去工作，然后在它们结束之后同意对数据进行整理，这样就可以极大的节约时间，从而提高用户
        体验效果。
 */
interface FightQuery{
    List<String> get();
}

class FightQueryTask extends Thread implements FightQuery{

    private final String origin;
    private final String destination;
    private final List<String> fightList = new ArrayList<>();

    public FightQueryTask(String airline,String origin,String destination){
        super("["+airline+"]");
        this.origin=origin;
        this.destination=destination;
    }

    @Override
    public void run() {
        System.out.printf("%s-query from %s to %s \n",getName(),origin,destination);

        int randomVal = ThreadLocalRandom.current().nextInt(10);
        try{
            TimeUnit.SECONDS.sleep(randomVal);
            this.fightList.add(getName()+"-"+randomVal);
            System.out.printf("The Fight:%s list query successful\n",getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public List<String> get() {
        return this.fightList;
    }
}

class FightQueryExample{
    private static List<String> fightCompany = Arrays.asList(
            "CSA","CEA","HNA"
    );

    public static void test() {
        List<String> results = search("SH","BJ");
        System.out.println("=================result=================");
        results.forEach(System.out::println);
    }

    private static List<String> search(String original,String dest){
        final List<String> result = new ArrayList<>();

        List<FightQueryTask> tasks = fightCompany.stream()
                .map(f->createSearchTask(f,original,dest))
                .collect(toList());

        tasks.forEach(Thread::start);
        tasks.forEach(t->{
            try{
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        tasks.stream().map(FightQueryTask::get)
                .forEach(result::addAll);

        return result;
    }

    private static FightQueryTask createSearchTask(
            String fight,
            String original,
            String dest
    ){
        return new FightQueryTask(fight,original,dest);
    }
}

/*
 *************************************************************************
 *************************************************************************
 *************************************************************************
 *************************************************************************
 */

/*
    3.9 如何关闭一个线程

    3.9.1 正常关闭
        1.线程结束，生命周期正常结束
        2.捕获中断信号关闭线程
            用过new Thread的方法创建线程，因此在用这种方式创建的一个线程中往往会循环地执行
            某个任务，比如心跳检查，不断地接受网络消息报文等，系统决定退出的时候，可以借助中断
            线程的方式使其退出。
                ——因为用new Thread创建线程成本高，所以我们不能把它当快餐线程，所以我们
                    得让它疯狂的循环处理事务，又因为它在疯狂的循环，所以我们得用中断的方式
                    让它退出来。。。阿门
 */
class InterrupThreadExit{
    public static void test() {
        /*
            没有调用可中断方法的，可以利用检测标志位。。。
         */
        Thread t = new Thread(){
            public void run(){
                System.out.println("I will start work");
                while(!isInterrupted()){
                    //working
                }
                System.out.println("I will be exiting...");
            }
        };

        /*
            调用了可中断方法的，可以通过捕获中断异常。。。
         */
        Thread t2 = new Thread(){
            public void run(){
                System.out.println("I will start work");

                while(true){
                    try{
                        TimeUnit.MILLISECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        break;
                    }
                }

                System.out.println("I will be exiting...");
            }
        };

        t.start();
        try {
            TimeUnit.MINUTES.sleep(1);
            System.out.println("System will be shutdown.");
            t.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/*
        3.使用volatile开关控制
            由于interrupt标识很有可能白擦除，或者逻辑单元中不会调用任何可中断方法，所以使用
            volatile修饰的开关flag关闭线程也是一种常用的做法：
 */

class FlagThreadExit{
    static class MyTask extends Thread{
        private volatile boolean close = false;

        @Override
        public void run() {
            System.out.println("I will start work");
            while(close&&!isInterrupted()){
                //working
            }
            System.out.println("I will be exiting.");
        }

        public void close(){
            this.close=true;
            this.interrupt();
        }
    }

    public static void test() {
        MyTask t = new MyTask();
        t.start();
        try {
            TimeUnit.MINUTES.sleep(1);
            System.out.println("sys will be shutdown.");
            t.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

/*
    3.9.2 异常退出

    在一个线程的执行单元中，是不允许抛出checked异常的。如果线程在运行过程中需要捕获
    checked异常并且判断是否还有运行下去的必要，那么此时可以将checked异常封装封装
    成unchecked异常抛出，进而结束线程的生命周期。

    3.9.3 进程假死

    进程出现假死，可能是某个线程阻塞了，或者线程出现了死锁的情况。可以利用jstack、
    jconsole、jvisualvm等工具进行诊断。
 */

 

——《Java高并发编程详解》

转载于:https://www.cnblogs.com/junjie2019/p/10585451.html

weixin_30839881
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Thread详解
langzicanyue的博客
02-03 1486
线程概述 线程是现代操作系统调度的最小单元，一个进程可以创建多个线程来提高系统的吞吐量和执行效率。（进程是操作系统资源分配和调度的基本单位，它可以创建多个线程，进程可创建的线程数量和操作系统有关） 线程状态 如下图： Thread源码中定义了线程状态枚举 /** * 线程状态。线程可以处于以下状态之一 * NEW：尚未启动的线程处于此状态 * RUNNABLE：在java虚拟机中执行的线程处于此状态 * BLOCKED：被阻塞等待监视器锁定的线程处于此状态
Thread概述
tumu6889的博客
10-06 175
thread
Thread API详解
morris
02-22 2658
构造方法 Thread类提供了丰富的构造方法，具体如下： Thread() Thread(Runnable target) Thread(Runnable target, String name) Thread(String name) Thread(ThreadGroup group, Runnable target) Thread(ThreadGroup group, Runnable target, String name) Thread(ThreadGroup group, Runnable tar
ThreadAPI详解
xiaobeichen1的博客
03-05 133
ThreadAPI详解 线程休眠（sleep） sleep方法 public static void sleep(long milis) throws InterruptedException public static void sleep(long milis,int nanos) throws InterruptedExceptionInterruptedException sleep方法会使当前线程进入指定毫秒数的休眠，暂停执行，最终以系统的定时器和调度器的精度为准。 每个线程休眠都互不影响
Thread类API详解
java武林梦
05-28 2004
文章目录0.线程类常用API大纲1.Thread类描述2.线程API详解：2.1.Thread() 无参构造方法2.2 Thread(RUNABLE)2.3 currentThread()2.4 isAlive()2.5 join()2.6 sleep()2.7 yield()2.8 getState()2.9 interrupt()2.10 resumes()2.11 run()2.12 ...
Java高并发编程-Thread常用API详解（重点篇）
weixin_42737131的博客
06-16 228
没有强大的理论支撑的代码，都是自娱自乐，架构师带你学习多线程的原理到实战项目中的高并发解决方案，闲暇之余，分享技术干货，和喜爱技术的coder们一起交流，互相学习进步 本次主要和大家分享Thread常用API原理，我们工作中经常会用到Thread的一些api，那么这些API的原理大家又是否知道呢？不常用的API有哪些，了解这些之后，相信可以写出更优质的代码，少走弯路，同时也是面试必考的 sleep方法，线程休眠 1. 介绍 sleep方法根据传入的指定时间，进行休眠，线程进入sleep状态，不会释放
Thread API
小胖SUN
05-31 1047
记录下经常要用到的关于thread的相关API，并写为跨平台模式。方便以后使用。
RT-Thread API参考手册.pdf
12-20
RT-Thread是一款由国内团队开发并维护的嵌入式实时操作系统，拥有完全的自主知识产权。自成立以来，RT-Thread经过长时间的发展，已经成为了一个功能强大、组件丰富的物联网操作系统，尤其适应于资源受限的微控制器...
ThreadX API查询手册.chm
01-16
ThreadX操作系统 CHM格式的帮助文档,能够方便地查阅ThreadX的所有函数实现，函数定义，函数描述，函数实例，并且分类整理好了各个类别的函数。 各个相关联的函数API之间支持链接跳转，使用起来相当方便。 格式与VC...
transmittable-thread-local-2.12.2-API文档-中文版.zip
06-04
包含翻译后的API文档：transmittable-thread-local-2.12.2-javadoc-API文档-中文(简体)版.zip； Maven坐标：com.alibaba:transmittable-thread-local:2.12.2； 标签：alibaba、transmittable、thread、local、中文...
rt-thread操作系统API
07-08
该文档详细介绍了RT-Thread操作系统的核心组件和功能，包括系统移植、内核裁剪以及API使用方法。 1. RT-Thread诞生：RT-Thread最初是为一个小型手持设备而开发的，其内核在2006年上半年完成。它从一个具有简单IPC...
05 Thread类API详解-优雅的关闭线程
wyaoyao93的博客
09-06 372
05 优雅的关闭线程 文章目录05 优雅的关闭线程1 stop方法停用2 如何优雅的停止线程方式1 通过一个开关 来控制demo方式2 通过线程打断的方式3 强制中断 1 stop方法停用 因为它本质上是不安全的。停止线程会导致它解锁所有已锁定的监视器。（当ThreadDeath异常在堆栈中传播时，监视器被解锁。）如果之前由这些监视器保护的对象中的任何一个处于不一致状态，则其他线程现在可以以不一致的状态查看这些对象。据称这些物体被 损坏。当线程操作受损对象时，可能导致任意行为。这种行为可能微妙且难
thread api整理
oSanWenYu的专栏
03-14 728
rt_thread_t    rt_thread_find(char *name) ；  查找线程名字，成功返回线程句柄，失败返回NULL rt_err_t rt_thread_delay(rt_tick_t tick)； 阻塞tick长时间，进入suspend队列，被定时器唤醒 rt_err_t rt_thread_sleep(rt_tick_t tick)； 同上（sleep被
Java API：Thread
On my way
04-22 1470
第一次翻译，从APi开始。。。 API地址 java.lang Class Thread java.lang.Object java.lang.Thread All Implemented Interfaces: Runnable public class Threadextends Objectimplements Runnable A threa
Thread API 详细介绍
yisish的博客
05-23 1019
本文将从常用的Thread API 角度讲解线程相关的操作和用法 线程sleep，yield 线程优先级,获取线程ID，设置线程上下文加载器 线程的interrupt，join 如果关闭一个线程 线程sleep sleep 是一个静态方法，有两个重载方法，一个需要传入毫秒数，另外一个继续毫秒数也需要纳秒数 public static void sleep(long millis, int n...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3228
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
最新发布
追梦的鱼儿
09-04 274
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1227
浅析synchronized锁升级的原理与实现
Java多线程ThreadAPI深度解析
本文将详细介绍Thread API的使用，包括构造方法、线程名设置、线程组以及Runnable接口的应用。" 在Java中，创建线程主要有两种方式：继承Thread类和实现Runnable接口。Thread类提供了多种构造方法，让我们来看看...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值