Java关于线程创建和线程池-个人学习总结

最新推荐文章于 2024-08-11 20:00:32 发布
最新推荐文章于 2024-08-11 20:00:32 发布
阅读量132 收藏
点赞数
分类专栏： 学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PaiZhong/article/details/109234407
版权

线程与进程

进程

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行.。一个进程最少 有一个线程

线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

线程调度

分时调度

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

抢占式调度。

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

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻， 只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

同步与异步

同步:排队执行 , 效率低但是安全.
异步:同时执行 , 效率高但是数据不安全.

并发与并行

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

多线程创建的方式

通过继承Thread类创建线程类

  • 1.定义Thread类的子类，并重写该类的run（）方法。run（）方法就是该线程的执行体。

  • 2.创建子类实例，即创建了线程对象。

  • 3.调用线程对象的start（）方法来启动该线程。

注意：

  • 1.Java程序运行时有默认的主线程，它的方法体就是main()方法的方法体。

  • 2.使用继承Thread类的方法来创建线程类时，多个线程之间无法共享线程类的实例变量。

举例：

public class Main {
    public static void main(String[] args) {
        //创建一个进程
        MyThread m = new MyThread();
        //执行进程
        m.start();
        for (int i=0;i<10;i++){
            //输出Java程序运行时默认运行的主线程名称
            System.out.println("主线程 " + Thread.currentThread().getName() + "执行了" + i);
        }
    }
}
class MyThread extends Thread {
    //run（）就是线程要执行的任务方法
    public void run() {
        //这里的代码 就是一条新的执行路径
        //执行路径的触发方式，不是调用run方法，而是通过Thread对象的start()来启动任务
        for (int i = 0; i < 10; i++) {
            //使用线程的getName()可直接获取当前线程名称
            System.out.println("副线程 " + this.getName() + "执行了" + i);
        }
    }
}

结果：

主线程 main执行了0
主线程 main执行了1
主线程 main执行了2
主线程 main执行了3
副线程 Thread-0执行了0
主线程 main执行了4
副线程 Thread-0执行了1
主线程 main执行了5
副线程 Thread-0执行了2
主线程 main执行了6
副线程 Thread-0执行了3
主线程 main执行了7
副线程 Thread-0执行了4
主线程 main执行了8
副线程 Thread-0执行了5
主线程 main执行了9
副线程 Thread-0执行了6
副线程 Thread-0执行了7
副线程 Thread-0执行了8
副线程 Thread-0执行了9

因为多线程程序在执行的时候，多个线程在一个CPU上快速轮换执行，谁抢到时间片谁就运行，所以可能得到的输出结果并不相同。

通过实现Runnable接口创建线程类

  • 1.定义Runnable接口的实现类，并重写run（）。

  • 2.创建Runnable实现类的实例，并将它作为Target传入Thread对象。

  • 3.调用线程对象的start（）方法来启动线程。

注意：

使用这种方法，程序创建的Runnable对象只是线程的target，而多个线程可以共享同一个target，所以多个线程可以共享同一个线程类的实例变量。

举例：

public class runnable {
    public static void main(String[] args) {
        //实现Runnable
        //创建任务对象
        MyRunnable r = new MyRunnable();
        //创建线程,并为其分配一个任务
        Thread t = new Thread(r);
        //执行线程
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程 " + Thread.currentThread().getName() + " 执行了 " + i);
        }
    }
}

//用于给线程执行的任务
class MyRunnable extends Thread {
    public void run() {
        for (int i = 0; i < 10; i++) {
            //线程任务
            System.out.println("副线程 " + getName() + " 执行了 " + i);
        }
    }
}

结果：

主线程 main 执行了 0
主线程 main 执行了 1
副线程 Thread-0 执行了 0
副线程 Thread-0 执行了 1
副线程 Thread-0 执行了 2
副线程 Thread-0 执行了 3
副线程 Thread-0 执行了 4
副线程 Thread-0 执行了 5
副线程 Thread-0 执行了 6
副线程 Thread-0 执行了 7
副线程 Thread-0 执行了 8
副线程 Thread-0 执行了 9
主线程 main 执行了 2
主线程 main 执行了 3
主线程 main 执行了 4
主线程 main 执行了 5
主线程 main 执行了 6
主线程 main 执行了 7
主线程 main 执行了 8
主线程 main 执行了 9

与Thread类的区别是：前者直接创建的Thread子类即可代表线程对象；后者创建的Runnable对象只能作为线程对象的target。

实现Runnable与继承Thread相比有如下优势：

  • 1.通过创建任务，然后给线程分配任务的方式实现多线程，更适合多个线程同时执行任务的情况
  • 2.可以避免单继承所带来的局限性
  • 3.任务与线程是分离的，提高了程序的健壮性
  • 4.后期学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程
通过Callable和Future创建线程
相关方法

  • 1.boolean cancel(boolean mayInterruptIfRunning)：试图取消该Future关联的Callable任务。

  • 2.V get()：获取关联的任务的返回值。调用该方法将导致程序阻塞，必须等到子线程结束后才会得到返回值。

  • 3.V get(long timeout,TimeUnit unit)：获取关联的任务的返回值。该方法最多让程序阻塞timeout和unit指定时间，如果经过指定时间后Callable任务仍然没有返回值，则将抛出TimeoutException异常。

  • 4.boolean isCancelled()：如果在Callable任务完成之前被取消，则返回true

  • 5.boolean isDone()：如果任务已经完成，则返回true

Callable接口有泛型限制，接口中的泛型形参类型必须和call()方法返回值类型相同。而且Callable接口是函数式接口，因此可以使用Lambda表达式创建Callable对象。

使用该方法创建并启动线程的步骤类似于实现Runnable接口来创建线程，
举例：

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

public class callable {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<String> c = new MyCallable();
        //使用FutureTask来包装Callable对象
        FutureTask<String> task = new FutureTask<>(c);
        new Thread(task).start();
        //获取副线程返回值，此方法会阻塞主线程往下执行，不调用不会阻塞
        System.out.println(task.get());
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("主线程执行了 " + Thread.currentThread().getName() + i);
        }
    }
}

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 5; i++) {
            //让程序休眠1秒
            Thread.sleep(1000);
            System.out.println("副线程执行了 " + getClass() + i);
        }
        //结束返回的结果
        return "副线程结束了";
    }
}

结果：

副线程执行了 class thread.MyCallable0
副线程执行了 class thread.MyCallable1
副线程执行了 class thread.MyCallable2
副线程执行了 class thread.MyCallable3
副线程执行了 class thread.MyCallable4
副线程结束了
主线程执行了 main0
主线程执行了 main1
主线程执行了 main2
主线程执行了 main3
主线程执行了 main4

Runnable 与 Callable的相同点 ：

  • 都是接口；
  • 都可以编写多线程程序

都采用Thread.start()启动线程 Runnable 与 Callable的不同点 ：

  • Runnable没有返回值；

  • Callable可以返回执行结果

  • Callable接口的call()允许抛出异常；-

  • Runnable的run()不能抛出

创建线程的三种方式的对比：

采用Runnable和Callable接口的方式创建多线程的优缺点：

  • 线程类只实现了Runnable接口或者Callable接口，还可以继承其他类。

  • 多个线程可以共享一个target对象，非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，体现了面向对象的编程思想。

  • 编程稍微复杂些。

采用继承Thread类的方式创建多线程的优缺点：

  • 线程类已经继承了Thread类，不能再继承其他类。

  • 编程比较简单。

所以一般使用Runnable和Callable创建多线程。

线程池 Executors

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程 就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容 器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处
  • 降低资源消耗
  • 提高响应速度
  • 挺高线程的可管理性

Java中的四种线程池。ExecurtorService

缓存线程池
长度无限制
创建线程
创建任务
执行任务
关闭任务

任务加入后的执行流程:   
- 1.判断线程池是否存在空闲线程
- 2.存在则使用 
- 3不存在,则创建线程 并放入线程池, 然后使用 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Executor_Service1 {

    public static void main(String[] args) {
        //向线程池中加入新的任务
        ExecutorService service = Executors.newCachedThreadPool();
        //指挥线程池执行新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "任务1");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "任务2");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "任务3");
            }
        });

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
定长线程池
长度是指定的线程池

加入任务后的执行流程
   - 1 判断线程池是否存在空闲线程
   - 2 存在则使用
   - 3 不存在空闲线程  且线程池未满的情况下  则创建线程  并放入线程池中  然后使用
   - 4 不存在空闲线程  且线程池已满的情况下  则等待线程池的空闲线程

举例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Executor_Service2 {
    public static void main(String[] args) {
        //向线程池中加入新的任务，指定线程池长度
        ExecutorService service = Executors.newFixedThreadPool(2);
        指挥线程池执行新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "任务1");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "任务2");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "任务3");
            }
        });
    }
}

结果：

pool-1-thread-1任务1
pool-1-thread-2任务2
pool-1-thread-1任务3  //过了大概三秒出现
单程线程池
 效果与定长线程池 创建时传入数值1 效果一致.

 执行流程
    1 判断线程池的那个线程是否空闲
    2 空闲则使用
    3 不空闲则等待它空闲后再使用

举例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Executor_Service3 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"任务1");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"任务2");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"任务3");
            }
        });
    }
}

结果：

pool-1-thread-1任务1
pool-1-thread-1任务2
pool-1-thread-1任务3
周期性任务定长线程池
 执行流程
    1 判断线程池是否存在空闲线程
    2 存在则使用
    3 不存在空闲线程  且线程池未满的情况下  则创建线程  并放入线程池中  然后使用
    4 不存在空闲线程  且线程池已满的情况下  则等待线程池的空闲线程

    周期性任务执行时
            定时执行 当某个任务触发时 自动执行某任务

举例：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Executor_Service4 {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        //定时执行一次
        //参数1：定时执行的任务
        //参数2：时长数字
        //参数3：2的时间单位    Timeunit的常量指定
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "任务执行");
            }
        }, 5, TimeUnit.SECONDS);      //5秒钟后执行
    }
}

结果：

运行5秒后

pool-1-thread-1任务执行

举例：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Executor_Service4 {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        /*
        周期性执行任务
            参数1：任务
            参数2：延迟时长数字（第一次在执行上面时间以后）
            参数3：周期时长数字（每隔多久执行一次）
            参数4：时长数字的单位
        * **/
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"任务执行");
            }
        },5,1, TimeUnit.SECONDS);
    }
}

结果：

运行5秒后

pool-1-thread-1任务执行

之后每隔一秒

pool-1-thread-1任务执行
排中律
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 线程的创建与线程池
duzm200542901104的专栏
02-10 657
一、创建线程的三种方法 1、实现 Runnable 接口 2、继承 Thread 类本身 3、通过 Callable 和 Future 创建线程 二、创建线程的三种方式的对比 1. 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。 2、使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 th
java多线程创建runnable_Java线程池和runnables创建runnables
weixin_40003780的博客
02-27 135
有很多方法可以做你想要的 . 您需要小心，不要最终创建太多线程 .以下是一个示例，您可以使用ExecutorCompletionService提高效率，也可以使用Runnable .import java.util.ArrayList;import java.util.List;import java.util.Random;import java.util.concurrent.Callable...
一文看懂Java中创建线程的所有方式（继承Thread,实现Runnable，实现Callable,线程池）
qq_42107430的博客
04-02 449
一文看懂Java中创建线程的所有方式 好像有点标题党的感觉，但是干货绝对多，绝对有收获 本文部分参考周阳老师大厂面试题第二讲 觉得有用，点个赞吧 目录 1、继承Thread类 2、实现Runnable接口 3、 实现callable接口 4、使用线程池 线程池的几个重要参数介绍 线程池的底层工作原理 生产上如何合理设置线程池参数 自定义线程池 线程池的拒绝策略 面...
JavaSE复习之十二 高级特性：并发 (多线程) 补充（1）
十里の清风
03-25 254
 多线程u Threadu 线程创建u 线程池u 线程状态图第1章 多线程1.1 多线程介绍学习多线程之前，我们先要了解几个关于多线程有关的概念。进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。   线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这...
八：多线程的几种实现方式及使用Runnable接口的优势
qq_38022739的博客
08-31 471
一、继承Thread类创建线程 重写run方法，用start启动线程 public class MyThread extends Thread { 　　public void run() { 　　 System.out.println("MyThread.run()"); 　　} } MyThread myThread1 = new MyThread(); MyT...
JAVA并发编程实践-线程池-学习笔记
07-22
Java并发编程实践中的线程池是一个关键的概念，它在多线程编程中扮演着至关重要的角色，有效地管理和调度线程资源，以提高系统的性能和效率。线程池通过复用已存在的线程来减少线程的创建和销毁开销，避免了频繁的上...
线程-线程池-锁-集合-Map-队列.docx
05-18
在Java中，使用`ExecutorService`和`ThreadPoolExecutor`来创建线程池，而不是直接使用`Executors`，因为`Executors`创建的线程池可能会导致资源耗尽的问题。 集合是Java中存储数据的主要工具，包括List、Set和Map...
Java特别篇-关于线程创建的三种方式的总结对比
02-04
### Java特别篇-关于线程创建的三种方式的总结对比 #### 一、常见3种创建线程的方式 ##### （1）方式1：继承Thread类的方式 - **创建步骤**： - 创建一个类，继承`Thread`类。 - 重写`run()`方法，该方法将包含...
Java中的线程与线程池.pptx
01-20
Java中的线程与线程池是程序设计中的关键概念，特别是在多任务并行处理和优化系统性能时。本文档深入探讨了这两个主题，旨在帮助开发者更好地理解和应用它们。 线程是为了充分利用CPU资源而引入的执行单元。在多...
26_多线程_第1天（Thread、线程创建、线程池）_讲义
02-16
在Java编程语言中，多线程是并发执行任务的关键机制，极大地提高了程序的效率和响应速度。...通过Thread类、线程创建方法以及线程池的使用，开发者能够更好地管理和调度系统资源，以实现高效的并发处理。
线程创建的四种方式
热门推荐
m0_37840000的博客
03-30 18万+
java中创建线程的四种方法以及区别 Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程，如下所示： 1）继承Thread类创建线程 2）实现Runnable接口创建线程 3）使用Callable和Future创建线程 4）使用线程池例如用Executor框架 下面让我们分别来看看这四种创建线程的方法。 --...
继承Thread类创建一个线程
xiueer
10-14 590
class Demo extends Thread { // 覆盖run()方法； public void run() { for (int i = 0; i < 60; i++) System.out.println("dome run" + i); } }public class ThreadDemo { public stat
线程池实现线程的创建 的两种方法
weixin_43308935的博客
11-29 398
package cn.itcast.demo5; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /* JDK1.5新特性,实现线程池程序 使用工厂类 Executors中的静态方法创建线程对象,指定线程的个数 static ExecutorService newFixedTh...
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 299
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
（javaweb）请求响应postman
2301_79144798的博客
08-08 473
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 215
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 251
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Spring事务
c1tenj2的博客
08-07 440
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
反射和注解
supercool7的博客
08-08 260
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 396
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值