Java基础之线程篇

最新推荐文章于 2022-07-06 23:09:26 发布
最新推荐文章于 2022-07-06 23:09:26 发布
阅读量295 收藏 1
点赞数 3
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ks2356/article/details/114481284
版权

什么是线程？

线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

线程的状态：

  1. 新建(NEW)：新创建了一个线程对象。
  2. 可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。
  3. 运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。
  4. 阻塞(BLOCKED)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种：
  • 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
  • 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
  • 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。
  1. 死亡(DEAD)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

实现线程的方式

1.继承Thread类

package com.sk.Multithreading;

public class ThreadDemo {

    public static void main(String[] args) {
        MyThread thread1 = new MyThread("玉无双");
        MyThread thread2 = new MyThread("花辞树");
        MyThread thread3 = new MyThread("醉星河");
        thread1.start();//启动线程,只能调用一次start()方法，否则会抛出java.lang.IllegalThreadStateException
        thread2.start();
        thread3.start();
    }
}

class MyThread extends Thread {
    String name;

    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name+Thread.currentThread().getName());
    }
}

start方法的作用就是将线程由NEW状态，变为RUNABLE状态。start()方法内部调用的是start0()native方法启动。当线程创建成功时，线程处于NEW（新建）状态，如果你不调用start( )方法，那么线程永远处于NEW状态。（每个线程类对象只能调用一次）调用start( )后，才会变为RUNABLE状态，线程才可以运行。（不一定就会立即执行，线程要等待CPU调度）。当线程被cpu调度，就会让线程去执行run方法。

public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

2.实现Runnable接口

Java里的继承都是单一的有局限性，所以我们可以通过实现Runnable 接口来创建线程（Thread类实现了Runnable 接口）。

package com.sk.Multithreading;

public class ThreadDemo {

    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyThread("玉无双"));//传入一个实现Runnable 接口的对象
        Thread thread2 = new Thread(new MyThread("花辞树"));
        Thread thread3 = new Thread(new MyThread("醉星河"));
        thread1.start();
        thread2.start();
        thread3.start();

    }
}

class MyThread implements Runnable {
    String name;

    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name+Thread.currentThread().getName());
    }
}

3.实现Callable接口

Runnable接口有一个缺点：当线程执行完毕后，我们无法获取一个返回值。并且Runnable接口不会向上抛出异常，只能在run()方法里进行try catch，而Callbale可以向上抛异常，并且定义的时候可以设置一个泛型，此泛型的类型就是返回数据的类型。

package com.sk.Multithreading;

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

public class ThreadDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> task1 = new FutureTask(new MyThread("玉无双"));
        FutureTask<String> task2 = new FutureTask(new MyThread("花辞树"));
        FutureTask<String> task3 = new FutureTask(new MyThread("醉星河"));
        new Thread(task1).start();
        String s1 = task1.get();
        System.out.println(s1);
        
        new Thread(task2).start();
        String s2 = task2.get();
        System.out.println(s2);
        
        new Thread(task3).start();
        String s3 = task3.get();
        System.out.println(s3);

    }
}

class MyThread implements Callable<String> {
    String name;

    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        System.out.println(name+Thread.currentThread().getName());
        return name;
    }
}

4.线程池

4.1实现方式

1、newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。（可以使得任务快速得到执行，因为任务时间执行短，可以很快结束，也不会造成cpu过度切换）

package com.sk.Multithreading;

import java.util.concurrent.*;

public class ThreadDemo {

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newCachedThreadPool();
        try {
            for (int i = 1; i <= 10; i++) {//模拟10个任务
                threadPool.execute(() -> System.out.println(Thread.currentThread().getName() + "处理任务"));
                //TimeUnit.MILLISECONDS.sleep(100);//休息100ms
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }

    }
}

效果
在这里插入图片描述
休息100ms，看线程是否可以复用。

在这里插入图片描述

2、newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。（保证线程数可控，不会造成线程过多，导致系统负载更为严重）

package com.sk.Multithreading;

import java.util.concurrent.*;

public class ThreadDemo {

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        try {
            for (int i = 1; i <= 10; i++) {//模拟10个任务
                threadPool.execute(() -> System.out.println(Thread.currentThread().getName() + "处理任务"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }

    }
}

效果
在这里插入图片描述

3、newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务。

package com.sk.Multithreading;

import java.util.concurrent.*;

public class ThreadDemo {

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        try {
            for (int i = 1; i <= 10; i++) {//模拟10个任务
                threadPool.execute(() -> System.out.println(Thread.currentThread().getName() + "处理任务"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }

    }
}

效果
在这里插入图片描述

4、newScheduledThreadPool：适用于执行延时或者周期性任务。

package com.sk.Multithreading;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.*;

public class ThreadDemo {

    public static void main(String[] args)  {
        ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println("时间:"+sdf.format(new Date()));
        try {
            for (int i = 1; i <= 10; i++) {//模拟10个任务
                threadPool.schedule(new Runnable(){
                    @Override
                    public void run() {
                        System.out.println("时间:" + sdf.format(new Date())+Thread.currentThread().getName()+"处理任务");
                    }
                },3,TimeUnit.SECONDS);//延时3秒后执行
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }

    }
}

效果

在这里插入图片描述

5、newWorkStealingPool：可以传入线程的数量，不传入，则默认使用当前计算机中可用的cpu数量，适用于耗时严重的任务。（Java8新增的）

package com.sk.Multithreading;

import java.util.concurrent.*;

public class ThreadDemo {

    public static void main(String[] args) {
        ExecutorService stealingPool = Executors.newWorkStealingPool();
        try {
            for (int i = 1; i <= 10; i++) {//模拟10个任务
                int finalI = i;
                stealingPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t" + finalI + "处理任务");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            stealingPool.shutdown();
        }
        while (Thread.activeCount() > 2) {

        }
    }
}

效果
在这里插入图片描述

4.2参数详解

1、corePoolSize（核心线程池基本大小）：当向线程池提交一个任务时，若线程池已创建的线程数小于corePoolSize，即便此时存在空闲线程，也会通过创建一个新线程来执行该任务，直到已创建的线程数大于或等于corePoolSize时，（除了利用提交新任务来创建和启动线程（按需构造），也可以通过 prestartCoreThread() 或 prestartAllCoreThreads() 方法来提前启动线程池中的基本线程。）

2、maximumPoolSize（线程池最大大小）：线程池所允许的最大线程个数。当队列满了，且已创建的线程数小于maximumPoolSize，则线程池会创建新的线程来执行任务。另外，对于无界队列，可忽略该参数。

配置线程池最大线程数

  • CPU密集型（任务需要大量运算，没有阻塞，CPU一直全速运行）最大线程数=CPU核数+1
  • IO密集型（任务线程并不是一直在执行任务）：最大线程数 = CPU核数*2 或 最大线程数 = CPU核数/(1-阻塞系数)(阻塞系数的值一般在0.8~0.9)

3、keepAliveTime（线程存活保持时间）当线程池中线程数大于核心线程数时，线程的空闲时间如果超过线程存活时间，那么这个线程就会被销毁，直到线程池中的线程数小于等于核心线程数。

4、unit（单位）keepAliveTime参数的时间单位。
5、workQueue（任务队列）：用于传输和保存等待执行任务的阻塞队列。

6、threadFactory（线程工厂）：用于创建新线程。threadFactory创建的线程也是采用new Thread()方式，threadFactory创建的线程名都具有统一的风格：pool-m-thread-n（m为线程池的编号，n为线程池内的线程编号）。

7、handler（拒绝策略4种）：当线程池和队列都满了，再加入线程会执行此策略。

  • ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。（默认）
  • ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。
  • ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务
  • ThreadPoolExecutor.CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务

注意：线程池Executors创建线程底层其实调用的是ThreadPoolExecutor 类去创建。阿里开发手册强制：线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

以下是阿里手册规范

线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这
样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明：Executors 返回的线程池对象的弊端如下：
1） FixedThreadPool 和 SingleThreadPool：
允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2） CachedThreadPool：
允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

    /**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters and default thread factory and rejected execution handler.
     * It may be more convenient to use one of the {@link Executors} factory
     * methods instead of this general purpose constructor.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
4.3线程池运行流程

1、判断核心线程池是否已满，没满则创建一个新的工作线程来执行任务。满了则加入任务队列中。
2、判断任务队列是否已满，没满则将新提交的任务添加在工作队列，满了则启动最大线程数的线程来执行任务。
3、判断整个线程池是否已满，没满则创建一个新的工作线程来执行任务，已满则执行拒绝策略。

未见山
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java多线程之基础篇(一).docx
04-16
Java多线程是Java语言中的一个重要特性，它允许程序同时执行多个不同的任务，从而提高程序的效率和响应性。在操作系统层面，实现并发最常见的方式是通过进程和线程。进程是具有独立内存空间的执行单元，而线程是进程...
Java培训之基础篇 Java培训之基础篇
09-28
Java是世界上最流行的编程语言之一，尤其在企业级应用开发领域占据主导地位。本文将深入探讨Java的基础知识，帮助初学者理解和掌握Java的核心概念。 1. Java程序设计概述 - 冯诺依曼体系：Java编程是基于冯诺依曼...
java基础学习总结——线程(一)
qq_29663071的博客
01-18 304
一、线程的基本概念 　　 线程理解：线程是一个程序里面不同的执行路径 　　每一个分支都叫做一个线程，main()叫做主分支，也叫主线程。 　　程只是一个静态的概念，机器上的一个.class文件，机器上的一个.exe文件，这个叫做一个进程。程序的执行过程都是这样的：首先把程序的代码放到内存的代码区里面，代码放到代码区后并没有马上开始执行，但这时候说明了一个进程准备开始
JAVA基础-多线程
HelloWorld!
04-27 483
程序、进程、线程 程序：由高级语言编写，然后在编译的过程中，被编译器/解释器转译为机器语言，从而得以执行 顺序执行时的主要特征包括顺序行，封闭性，可再现性 进程：进程是程序的一次执行，该程序可以和其他程序并发执行。是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。 进程是由程序、数据和进程控制块组成。 线程：是程序的执行单元，执行路径。是程序使用CPU的...
Java线程基础
weixin_40536930的博客
09-06 608
Java中线程的声明周期： Java线程中的状态 初始状态（New） 当线程对象创建后，则进入开启一个线程状态（Thread t = new MyThread();） 就绪状态（Runnable） 当调用线程对象的start()方法（t.start()），线程进入了就绪状态。处于就绪状态的线程，知识说明此线程已经做好了准备，随时等待CPU调度执行，并不是说明调用了start方法茨县丞...
java基础之线程
清风自来
01-08 125
一、线程的优先级 一个进程可以并发多个线程，每条线程执行不同的功能。一个线程不能独立存在，它必须试进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。 每个java线程都有一个优先级，java线程的优先级是一个整数，其取值范围是1（Thread.MIN_PRIORITY）-（Thread.MAX_PRIORITY）。线程的默认优先级为NORM_PRIORITY(5)。 具有高...
Java多线程之基础篇(二).docx
04-16
Java 多线程是Java语言中的一个重要特性，它允许程序同时执行多个任务，从而提高了程序的效率和响应性。在Java中，多线程的实现...理解和熟练掌握这些知识点是开发高并发应用的基础，也是提升Java程序员技能的关键。
Java第九章多线程程序设计基础篇.ppt
11-13
Java 多线程程序设计基础 多线程程序设计是 Java 语言的一个重要特性，允许程序同时执行多个任务，从而提高程序的效率和响应速度。本章将详细介绍 Java 多线程程序设计的基础知识。 §9.1 线程的概念 在 Java 中...
Java基础知识篇.rar
最新发布
03-19
Java基础知识是每个Java开发者必须掌握的，本资料详细总结了这一领域的核心概念。 1. **Java环境搭建**：要开始学习Java，首先需要安装Java Development Kit（JDK），它包含编译器、调试器和其他开发工具。配置好...
Java基础—线程
xiaosao_的博客
06-19 180
Java基础中的线程
Java基础线程
qq_56996036的博客
07-06 175
Java基础
Java基础之线程
wangyongyao1989的博客
06-04 598
一.线程和进程：    几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行的程序就是一个进程。当一个程序运行时，内部可能包含多个顺序执行流，每个执行流就是一个线程。   进程：当一个程序进入内存运行时，即成为一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。     进程具有三个特征:        独立性：
Java基础篇--线程
weixin_61500949的博客
05-24 169
一、线程的概念： 1.线程：是进程中的单个顺序控制流，是一条执行路径 二、线程分类： 1.单线程：一个进程如果只有一条执行路径，则称为单线程程序 2.多线程：一个进程如果有多条执行路径，则称为多线程程序 三、多线程的实现方式： 1.继承Thread类： 定义一个类继承Thread类并重写run()方法 2.实现Runnable接口： 定义一个类实现Runnable接口并重写run()方法 public class Sum extends T...
Java基础之——Java 线程
前尘忆梦的博客
02-03 4850
Java 线程 1、创建线程类（方法一） Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是 Thread 类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java 使用线程执行体来代表这段程序流。 Java 中通过继承 Thread 类来创建并启动多线程的步骤如下： 定义 Thread 类的子类，并重写该类的 run() 方法，该 run() 方法的方法体就代表了线程需要完成的任务，因此把 run() 方法称为线程执行体。
Java 线程基础
m0_50414588的博客
04-02 238
一、线程简介 什么是进程 简言之，进程可视为一个正在运行的程序。它是系统运行程序的基本单位，因此进程是动态的。进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动。进程是操作系统进行资源分配的基本单位。 什么是线程 线程是操作系统进行调度的基本单位。线程也叫轻量级进程（Light Weight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。 进程和线程的区别 一个程序至少有一个进程，一个进程至少有一个线程。
Java基础——线程基础
Wen先森的博客
04-28 155
线程相关概念 程序 程序就是为完成特定任务、用某种语言编写的一组指令的集合。简单来说就是我们写的代码。 进程 进程是指运行中的程序，比如我们打开一个应用，就是启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用另一个应用，又启动了一个进程，操作系统就会为该应用分配新的内存空间。（简单来讲就是运行几个程序） 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程。 什么是线程 线程有进程创建的，是进程的一个实体。 一个进程可以有多个线程。 其他
Java基础：通过Runnable接口创建线程
"这篇资料是关于Java编程的基础教程，通过Runnable接口实现多线程，并介绍了Java的学习路径和核心知识点。" 在Java编程中，多线程是一个关键的概念，它允许程序同时执行多个任务，提高效率。这个示例通过实现...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值