创建线程的四种方式、线程状态、核心线程是否会回收

已于 2022-08-23 17:45:08 修改
阅读量1k 收藏 2
点赞数 1
分类专栏： Java 文章标签： java
于 2020-10-29 20:54:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34497272/article/details/109205295
版权

文章目录

创建线程的四种方式

  • 继承Thread类
  • 实现Runnable接口
  • 实现Callable接口(有返回值)
  • 线程池(常用)

一、继承Thread类

  1. 继承Thread类
  2. 重写run()方法，将所要完成的任务代码写进run()方法中
  3. 调用该对象的start()方法，即可开启线程；
public class Thread01 extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--》执行run方法");
    }

    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread01 thread01 = new Thread01();
        thread01.setName("继承thread");
        thread01.start();
        System.out.println("主线程结束");
    }
}
// 主线程开始
// 主线程结束
// 继承thread--》执行run方法

二、实现Runnable接口

  1. 实现Runnable接口
  2. 重写run()方法，将所要完成的任务代码写进run()方法中
  3. 启动线程，需要首先实例化一个 Thread，并传入自己的线程实例
  4. 实例化的thread调用start方法
public class Thread02 implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--》执行run方法");
    }

    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread thread = new Thread(new Thread02());
        thread.setName("实现runnable");
        thread.start();
        System.out.println("主线程结束");
    }
}
// 主线程开始
// 主线程结束
// 实现runnable--》执行run方法

三、实现Callable接口(有返回值)

  1. 创建一个类并实现Callable接口(有返回值)
  2. 重写call()方法，将所要完成的任务的代码写进call()方法中，有返回值，并且可以抛出异常
  3. 需要创建Future接口的实现类的对象，即FutureTask类的对象，调用该对象的get()方法可获取call()方法的返回值
  4. 使用Thread类的有参构造器创建对象，将FutureTask类的对象当做参数传进去，然后调用start()方法开启并运行该线程。
public class Thread03 implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"--》执行run方法");
        return Thread.currentThread().getName();
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("主线程开始");
        FutureTask<String> task = new FutureTask<>(new Thread03());
        Thread thread = new Thread(task);
        thread.setName("实现runnable");
        thread.start();
        System.out.println("主线程结束");
        // get方法会阻塞线程
        String str = task.get();
        System.out.println("主线程输出-->"+str);
    }
}
// 主线程开始
// 主线程结束
// 实现runnable--》执行run方法
// 主线程输出-->实现runnable

四、线程池

4.1：newFixedThreadPool（定长线程池）

newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。底层使用的是ThreadPoolExecutor（线程执行池），任务使用LinkedBlockingQueue，核心线程池大小和最大线程树大小均为固定值

	// 有固定数量的线程池
    public static void test01(){
        // new一个有固定数量的线程池,最多只有五个线程在同时执行，其他的会在等待
        ExecutorService service = Executors.newFixedThreadPool(5);

        System.out.println(service);
        for (int i = 0; i < 7; i++) {
            service.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

        // jdk1.8
        service.execute(()->{
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // [Running, pool size = 5, active threads = 5, queued tasks = 2, completed tasks = 0]
        // 正在运行 链接池大小为5 活跃的线程为5  等待线程为2 已完成的线程为0
        System.out.println(service);

        // 停止线程池，以加入线程池的可正常执行
        // 将线程状态改为Shutting down
//        service.shutdown();
        // 线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务
//        service.shutdownNow();

        // [Shutting down, pool size = 5, active threads = 5, queued tasks = 2, completed tasks = 0]
        // Shutting down正在停止运行中
        System.out.println(service);
        System.out.println(service.isTerminated());
        System.out.println(service.isShutdown());

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // [Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 7]
        // 线程池彻底终止
        System.out.println(service);
        System.out.println(service.isTerminated());
        System.out.println(service.isShutdown());
    }
4.2：newCachedThreadPool（可缓存线程池）

newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。底层使用的是ThreadPoolExecutor（线程执行池），任务使用SynchronousQueue，核心线程池大小默认为0，最大线程树大小默认为int最大值

	// 可缓存线程池
    public static void test02(){
        // 可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
        ExecutorService service = Executors.newCachedThreadPool();
        System.out.println(service);
        for (int i = 0; i < 2; i++) {
            service.execute(() -> {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
        }
        System.out.println(service);

        // 默认回收时间为60秒
//        try {
//            TimeUnit.SECONDS.sleep(30);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }

        System.out.println(service);
        service.shutdown();
        // 测试主线程结束后，还能看到子线程的输出
        // 用于对比newWorkStealingPool，精灵线程
        System.out.println("~~~~~");
    }
4.3：newSingleThreadExecutor（单线程化的线程池）

newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。底层使用的是ThreadPoolExecutor（线程执行池），任务使用LinkedBlockingQueue，核心线程池大小和最大线程树大小默认为1

	// 单线程化的线程池
    public static void test03(){
        // 只有单线程，可以保证顺序执行
        ExecutorService service = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            service.execute(()->{
                System.out.println(Thread.currentThread().getName());
            });
        }
        service.shutdown();
    }
4.4：newScheduledThreadPool（定时及周期性任务）

newScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行。底层使用的是ScheduledThreadPoolExecutor（定时线程执行池），任务使用DelayedWorkQueue，核心线程池大小为固定值，最大线程树大小默认为int最大值

	// 定长线程池，支持定时及周期性任务执行
    public static void test04(){
        ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
        for (int i = 0; i < 10; i++) {
            // 要执行的任务、首次任务执行延迟时间、隔多久执行一次、时间单位
            service.scheduleAtFixedRate(()->{
                System.out.println(Thread.currentThread().getName());
            },1,2,TimeUnit.SECONDS);
        }

        try {
            TimeUnit.SECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.shutdown();
    }
4.5：newWorkStealingPool（工作窃取线程池）

newWorkStealingPool：工作窃取线程池，假设ABC三个线程，若C线程执行结束，线程C会从AB中窃取未完成的任务进行工作。使用的是ForkJoinPool,属于精灵线程（守护线程、后台线程）

public class Test04_WorkStealingPool {

    public static void main(String[] args) {
        // 可运行的线程树
        // 16 可以同时运行16个线程
        System.out.println(Runtime.getRuntime().availableProcessors());
        ExecutorService service = Executors.newWorkStealingPool();

        service.execute(new R(1));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));
        service.execute(new R(2));

        // 其他线程为非精灵线程，主线程
        // 由于产生的是精灵线程（守护线程、后台线程），主线程不阻塞的话，看不到输出
        // 阻塞主线程
//        try {
//            System.in.read();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.shutdown();
    }

    // 定义一个类实现Runnable
    static class R implements Runnable{
        int time;
        public R(int time) {
            this.time = time;
        }

        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
        }
    }
}
4.6：ForkJoinPool

ForkJoinPool： Fork：分，Join：合，产生的线程由ForkJoinPool管理，采用了分而治之算法，按照自定义的规则，将大任务分为小任务，进行分而治之（递归），适合的是计算密集型的任务（大规模数据运算）

public class Test05_ForkJoinPool {
    // 求和数组
    static int[] nums = new int[1000000];
    // 每一个小任务计算的值不能超过此值
    static final int MAX_NUM = 50000;
    static Random r = new Random();
    static {
        for (int i = 0; i < nums.length; i++) {
            nums[i] = r.nextInt(100);
        }
        // stream 求和
        // 49478895
        // jdk新特性
        System.out.println(Arrays.stream(nums).sum());
    }

    /**
     * ForkJoinPool执行的类为ForkJoinTask<?> task，继承RecursiveAction
     * 没有返回值
     */
    static class AddTask extends RecursiveAction {

        int start;
        int end;

        public AddTask(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        protected void compute() {
            // 需要求和的数值小于等于最大值时才进行求和
            if(end-start <= MAX_NUM) {
                long sum = 0L;
                for(int i=start; i<end; i++) sum += nums[i];
                System.out.println("from:" + start + " to:" + end + " = " + sum);
            } else {
                //否则则进入递归
                int middle = start + (end-start)/2;

                AddTask subTask1 = new AddTask(start, middle);
                AddTask subTask2 = new AddTask(middle, end);
                subTask1.fork();
                subTask2.fork();
            }
        }
    }

    /**
     * 无返回值的
     */
    public static void test01(){
        ForkJoinPool pool = new ForkJoinPool();
        // public void execute(ForkJoinTask<?> task) {
        // pool.execute(new AddTask(0,nums.length));
        AddTask addTask = new AddTask(0, nums.length);
        pool.execute(addTask);

        // ForkJoinPool属于精灵线程所以需要阻塞，要不看不到结果
        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * ForkJoinPool执行的类为ForkJoinTask<?> task，继承RecursiveTask<Long>
     * 有返回值,返回值可以定义
     */
    static class AddTask01 extends RecursiveTask<Long> {

        int start;
        int end;

        public AddTask01(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        protected Long compute() {

            // 需要求和的数值小于等于最大值时才进行求和
            if(end-start <= MAX_NUM) {
                long sum = 0L;
                for(int i=start; i<end; i++) sum += nums[i];
                return sum;
            } else {
                //否则则进入递归
                int middle = start + (end-start)/2;

                AddTask01 subTask1 = new AddTask01(start, middle);
                AddTask01 subTask2 = new AddTask01(middle, end);
                subTask1.fork();
                subTask2.fork();

                // join会阻塞等待放回值
                return subTask1.join() + subTask2.join();
            }
        }
    }

    /**
     * 有返回值的
     */
    public static void test02(){
        ForkJoinPool pool = new ForkJoinPool();
        // public void execute(ForkJoinTask<?> task) {
        // pool.execute(new AddTask(0,nums.length));
        AddTask01 addTask = new AddTask01(0, nums.length);
        pool.execute(addTask);

        // ForkJoinPool属于精灵线程所以需要阻塞，要不看不到结果
        // join()有阻塞效果
        System.out.println(addTask.join());
    }

    public static void main(String[] args) {
        // 无返回值
//        test01();
        // 有返回值
        test02();
    }
}
4.7：ThreadPoolExecutor(自定义线程池，建议采用)

全参包含了7个参数（核心线程数、最大线程数、除核心线程外多余空闲线程在终止前等待任务最大时间、时间单位、阻塞队列、线程工厂、拒绝策略）

拒绝策略包含了四种：
1. new ThreadPoolExecutor.AbortPolicy()(默认)  当达到线程界限和队列容量时，再新加线程时直接报错
2. new ThreadPoolExecutor.CallerRunsPolicy()   "调用者运行"一种调用机制，该策略既不会抛弃线程也不会报错，而是将某些任务回退到调用者，从而降低新任务流量
3. new DiscardOldestPolicy()  抛弃任务中等待最久的任务，然后将当前任务尝试加入到当前队列尝试再次提交当前任务
4. new ThreadPoolExecutor.DiscardPolicy()  直接丢弃任务，不抛弃线程也不报错，如果允许丢弃任务，则可以选择这种方案

阻塞队列
1. ArrayBlockingQueue ：由数组结构组成的有界阻塞队列。
2. LinkedBlockingQueue ：由链表结构组成的有界阻塞队列。
3. PriorityBlockingQueue ：支持优先级排序的无界阻塞队列。
4. DelayQueue：使用优先级队列实现的无界阻塞队列。
5. SynchronousQueue：不存储元素的阻塞队列。
6. LinkedTransferQueue：由链表结构组成的无界阻塞队列。
7. LinkedBlockingDeque：由链表结构组成的双向阻塞队列。

public class Test06_ThreadPoolExecutorTest {

    public static void main(String[] args) {
        // 自定义线程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                // 核心线程数
                1,
                // 线程池中允许最大线程数
                // cpu密集型（类似for循环之类，不操作数据库）：服务器核心线程数+1（加一是为了减少频繁切换上下文）
                // io密集型（频繁操作数据库）：服务器核心线程数/（1-阻塞系数） 阻塞系数一般为0.8~0.9
                2,
                // 除核心线程数之后多余的空闲线程在终止之前等待新任务的最长时间
                1L,
                // 时间单位
                TimeUnit.SECONDS,
                // 阻塞队列
                new LinkedBlockingDeque<>(2),
                // 默认的线程工厂
                Executors.defaultThreadFactory(),
                // 当达到了线程界限和队列容量时，新来任务被阻塞时要使用的处理程序
                new ThreadPoolExecutor.DiscardPolicy());
        // new ThreadPoolExecutor.AbortPolicy()(默认)
        /**
         * java.util.concurrent.RejectedExecutionException
         */
        // 当达到线程界限和队列容量时，再新加线程时直接报错

        // new ThreadPoolExecutor.CallerRunsPolicy()
        // "调用者运行"一种调用机制，该策略既不会抛弃线程也不会报错，而是将某些任务回退到调用者，从而降低新任务流量

        // new DiscardOldestPolicy()
        // 抛弃任务中等待最久的任务，然后将当前任务尝试加入到当前队列尝试再次提交当前任务

        // new ThreadPoolExecutor.DiscardPolicy()
        // 直接丢弃任务，不抛弃线程也不报错，如果允许丢弃任务，则可以选择这种方案

        for (int i = 0; i < 6; i++) {
            pool.execute(()->{
                System.out.println(Thread.currentThread().getName() + "~~~~");
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        pool.shutdown();
    }
}

线程状态

新建状态（NEW）--> 就绪状态（RUNNABLE）--> 运行状态（RUNNING）--> 阻塞状态（BLOCKED）--> 线程死亡（DEAD）
  • 新建状态（NEW）
    当程序使用 new 关键字创建了一个线程之后，该线程就处于新建状态，此时仅由 JVM 为其分配内存，并初始化其成员变量的值
  • 就绪状态（RUNNABLE）
    当线程对象调用了 start()方法之后，该线程处于就绪状态。Java 虚拟机会为其创建方法调用栈和程序计数器，等待调度运行。
  • 运行状态（RUNNING）
    如果处于就绪状态的线程获得了 CPU，开始执行 run()方法的线程执行体，则该线程处于运行状
    态。
  • 阻塞状态（BLOCKED）
    阻塞状态是指线程因为某种原因放弃了 cpu 使用权，也即让出了 cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得 cpu timeslice 转到运行(running)状态。
    1. 等待阻塞（o.wait->等待对列）：运行(running)的线程执行 o.wait()方法，JVM 会把该线程放入等待队列(waitting queue)
      中。
    2. 同步阻塞(lock->锁池)：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则 JVM 会把该线程放入锁池(lock pool)中。
    3. 其他阻塞(sleep/join)：运行(running)的线程执行 Thread.sleep(long ms)或 t.join()方法，或者发出了 I/O 请求时，JVM 会把该线程置为阻塞状态。当 sleep()状态超时、join()等待线程终止或者超时、或者 I/O处理完毕时，线程重新转入可运行(runnable)状态。
  • 线程死亡（DEAD）
    线程会以下面三种方式结束，结束后就是死亡状态。
    1. 正常结束：run()或 call()方法执行完成，线程正常结束
    2. 异常结束：线程抛出一个未捕获的 Exception 或 Error。
    3. 调用 stop：直接调用该线程的 stop()方法来结束该线程—该方法通常容易导致死锁，不推荐使用。

核心线程是否会回收

在这里插入图片描述
根据上方源码备注，即使这个核心线程啥也不干(闲置状态)，也会保留核心线程的，除非配置了allowCoreThreadTimeOut这个属性。
在这里插入图片描述
根据源码显示，allowCoreThreadTimeOut默认为false，没有配置的情况下核心线程是不会被回收的。

// 自定义线程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                // 核心线程数
                1,
                // 线程池中允许最大线程数
                // cpu密集型（类似for循环之类，不操作数据库）：服务器核心线程数+1（加一是为了减少频繁切换上下文）
                // io密集型（频繁操作数据库）：服务器核心线程数/（1-阻塞系数） 阻塞系数一般为0.8~0.9
                2,
                // 除核心线程数之后多余的空闲线程在终止之前等待新任务的最长时间
                1L,
                // 时间单位
                TimeUnit.SECONDS,
                // 阻塞队列
                new LinkedBlockingDeque<>(2),
                // 默认的线程工厂
                Executors.defaultThreadFactory(),
                // 当达到了线程界限和队列容量时，新来任务被阻塞时要使用的处理程序
                new ThreadPoolExecutor.DiscardPolicy());
        // 是否允许核心线程超时
        pool.allowCoreThreadTimeOut(true);

当把allowCoreThreadTimeOut设置为true时，则核心线程在空闲超时后也会被回收。

郭咖啡
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
【怎么设置核心线程数也可以被回收?】
学无止境
03-28 518
/ 如果当前线程池中线程数大于核心线程数，那么就移除核心线程 this . remove(t);// 如果当前线程池中线程数等于核心线程数，那么就继续执行核心线程 this . prestartCoreThread();} } }使用以上两种方式，都可以让核心线程数也可以被回收。
终于搞清楚了，关于核心线程会不会回收
当我谈编程时我谈些什么
09-10 9808
关于线程池的回收 核心线程通常不会回收，java核心线程池的回收由allowCoreThreadTimeOut参数控制，默认为false，若开启为true，则此时线程池中不论核心线程还是非核心线程，只要其空闲时间达到keepAliveTime都会被回收。但如果这样就违背了线程池的初衷（减少线程创建和开销），所以默认该参数为false。 keepAliveTime是指当线程池中线程数量大于corePollSize时，此时存在非核心线程，keepAliveTime指非核心线程空闲时间达到的阈值会被回收。
疑问线程对象Thread启动之后,没有任何引用引用这个Thread对象,是否会被GC回收掉
走自己的路
04-11 4384
public class MyRunnable implement Runnable{    public void run(){        while(true){           System.out.println("Hello");        }   }  public static void main(String[] args) {          new
线程池的线程回收问题
最新发布
m0_62565675的博客
08-02 607
线程池的线程回收问题
并发面试题：线程池的线程回收
wcy_frist的博客
06-10 237
因为工作线程都是从阻塞队列里面去获取执行任务的，所以只要在一定的时间内，阻塞队列没有任何可以处理的任务，那么这些线程就可以结束了，而这个功能是通过阻塞队列里面的poll()方法来完成的。这个方法里面提供了超时时间和超时时间单位这两个参数，当前线程在指定的时间内没有从阻塞队列里面获取任务的时候，那么poll()方法就会返回null，从而去终止线程，完成对线程的回收。核心线程和非核心线程的数量是在构造线程池的时候去设置的，也可以动态的进行更改，由于非核心线程是为了解决任务过多的情况下临时增加的。
Java创建线程的两种方式
09-01
Java提供了两种主要的方式来创建线程，分别是继承`Thread`类和实现`Runnable`接口。这两种方式各有优缺点，适用于不同的场景。 ### 继承Thread类 当你选择继承`Thread`类来创建线程，你需要按照以下步骤操作： 1....
day17_线程创建、线程同步、线程状态.pdf
11-02
本节课主要讲解了Java多线程编程的基础知识，包括线程的概念、线程与进程的区别、多线程的随机性、Java程序的进程中的线程、线程的创建方式、线程的执行流程、线程内存图等。 1. 进程与线程的概念 在计算机科学中...
Java并发编程示例(七)：守护线程的创建和运行
09-04
在Java编程中，守护线程（Daemon Thread）是一种特殊的线程类型，它的主要特点是当所有非守护线程（用户线程）结束时，守护线程也会随之终止，即使守护线程本身仍在运行。守护线程通常被用作后台服务，如垃圾回收、...
分离状态创建线程
09-10
在任何一个时间点上，线程是可结合的（joinable），或者是...在被其他线程回收之前，它的存储器资源（如栈）是不释放的。相反，一个分离的线程是不能被其他线程回收或杀死的，它的存储器资源在它终止时由系统自动释放。
PHP线程的内存回收问题
12-18
那么如果这个线程不结束，怎么回收内存呢？ refcount：引用技术器，可以理解为指向该个容器的指针个数吧。 is_ref：是否被引用（只可能是0或者1） 赋值的流程： <?php $a = 'aa'; xdebug_debug_zval(a); //...
面试题集锦-线程池-线程池中的线程回收问题
u012294039的专栏
06-22 404
先看面试题 定义了如下的线程池,当前线程池的活跃线程数为3(2个核心线程+1个非核心线程),处理完各自的任务都处于waiting状态.每隔3秒往该现场池提交一个任务,那么30秒后线程池的活跃线程数为多少? ThreadPoolExecutor executorService = new ThreadPoolExecutor(2, 3, 30, TimeUnit.SECONDS, new LinkedBlockingQueue<>(2), .
java new一个线程执行完后会自动销毁吗_Java基础总结，超级全的面试题
笔记
02-04 4820
1. static关键字是什么意思？Java中是否可以覆盖(override)一个 private 或者是 static的方法？是否可以在 static 环境中访问非static 变量？ static关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。    Java中static方法不能被覆盖，因为方法覆盖(override)是基于运行时动态绑定的，而 static 方法是编译时静态绑定的。static 方法跟类的任何实例都不相关，所以概念上不适用。   不可以在s..
JVM系统线程
weixin_45650737的博客
10-13 360
虚拟机线程：这种线程的操作时需要JVM达到安全点才会出现。这些操作必须在不同的线程中发生的原因是他们都需要JVM达到安全点，这样堆才不会变化。这种线程的执行类型包括“stop-the-world”的垃圾收集，线程栈收集，线程挂起以及偏向撤销。 周期任务线程：这种线程是时间周期性事件的体现（比如中断），他们一般用于周期性操作的调度执行。 GC线程:这种线程对 ...
方法中创建线程池，方法结束后线程池会被垃圾回收吗？
zx1323的博客
07-08 4180
线程池的坑, 一定要注意
Java线程是否会被垃圾回收
飘一笑的JAVA
01-21 6095
如果将线程启动后，然后线程变量置空，线程会怎么样？ import java.lang.ref.WeakReference; public class TestThread {   public static void testUnreferencedThread() {         // anonymous class extends Thread
java 引用被回收_java - 没有引用的新Thread()什么时候会被垃圾回收
weixin_34970098的博客
03-07 826
在下面的示例中，new Thread()没有任何引用。可能是被废弃的垃圾收集了吗？同样，在不扩展Thread类或实现可运行的情况下，我们如何创建线程？public class TestFive {private int x;public void foo() {int current = x;x = current + 1;}public void go() {for(int i = 0; i &...
【Linux多线程编程】2.线程创建与回收
CSDNGuoYuying的博客
01-03 563
线程创建、回收、生产者-消费者简单模型
线程池BUG复现和解决
记事本
08-16 2757
线程池BUG复现和解决
Java并发编程系列30:抛出异常 java.util.concurrent.RejectedExecutionException
fen_fen的专栏
05-20 8970
1、背景介绍 Java使用线程池newFixedThreadPool针对算法进行并发测试时，出现以下错误java.util.concurrent.RejectedExecutionException Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.cipherxxxcrypto.pertest.SM4PerTest$DecTask@76ed5528 rejected from ja
pthread_create创建的线程会自动回收吗
07-08
pthread_create函数创建的线程在执行完毕后，并不会自动回收。线程的回收需要通过其他机制来实现。一种常见的做法是使用pthread_join函数，在主线程中调用pthread_join等待目标线程结束，并回收其资源。 pthread_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值