多线程的实现

最新推荐文章于 2023-07-22 19:39:49 发布
最新推荐文章于 2023-07-22 19:39:49 发布
阅读量159 收藏
点赞数
分类专栏： 多线程 文章标签： java jvm servlet
原文链接：https://blog.csdn.net/zdl66/article/details/126297036
版权

一.多线程的四种实现方式

1.通过继承Threa类

  • 实现步骤

    • 自定义一个类MyThread类，用来继承与Thread类

    • 在MyThread类中重写run（）方法

    • 在测试类中创建MyThread类的对象

    • 使用对象调用start方法，启动线程。

  • 缺点

    • 这种方法是显式创建线程，有可能导致创建线程和销毁线程所花的时间以及系统资源开销过大，从而导致内存消耗完或者"过度切换"的问题

  • MyThread类

    package com.test.multithreading;
​
/**
 * @author welcome
 */
public  class MyThread extends Thread{
    public MyThread() {
    }
​
    public  MyThread(String name) {
        super(name);
    }
​
    @Override
    public  void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(this.getName()+" : "+i);
        }
    }
}
    ​

  • 测试类

    package com.test.dy;
​
import com.test.multithreading.MyThread;
​
/**
 * @author welcome
 */
public class Demo01 {
    public  static void main(String[] args) {
        MyThread t01=new MyThread();
        MyThread t02=new MyThread();
        MyThread t03=new MyThread();
​
        t01.start();
        t02.start();
        t03.start();
​
        t01.setName("线程1");
        t02.setName("线程2");
​
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
        }
    }
}
    ​

2.实现Runnable接口

  • 实现步骤

    • 自定义一个MyRunnable类来实现Runnable接口

    • 在MyRunnable类中重写run（）方法

    • 创建Thread对象，并把MyRunnable对象作为Tread类构造方法的参数传递进去

    • 使用对象调用start方法，启动线程。

  • 缺点

    • 这种方法是显式创建线程，有可能导致创建线程和销毁线程所花的时间以及系统资源开销过大，从而导致内存消耗完或者"过度切换"的问题

  • MyRunnable类

    package com.test.multithreading;
​
/**
 * @author welcome
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
        }
    }
}
    ​

  • 测试类

    package com.test.dy;
​
import com.test.multithreading.MyRunnable;
​
/**
 * @author welcome
 */
public class Demo02 {
    public static void main(String[] args) {
        MyRunnable myRun=new MyRunnable();
​
        Thread t01=new Thread(myRun,"线程1");
        Thread t02=new Thread(myRun,"线程2");
        Thread t03=new Thread(myRun,"线程3");
​
        t01.start();
        t02.start();
        t03.start();
​
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+" : "+i);
                }
            }
        });
    }
​
}
    ​

3.通过Callable和Future接口创建线程

  • 实现步骤

    • 自定义一个MyCallable类来实现Callable接口

    • 在MyCallable类中重写call()方法

    • 创建FutureTask，Thread对象，并把MyCallable对象作为FutureTask类构造方法的参数传递进去，把FutureTask对象传递给Thread对象。

    • 使用对象调用start方法，启动线程。

  • 优点

    • 可以借助FutureTask类，获取返回结果

    • 相比run()方法，可以有返回值

    • 方法可以抛出异常

    • 支持泛型的返回值

  • 缺点

    • 这种方法是显式创建线程，有可能导致创建线程和销毁线程所花的时间以及系统资源开销过大，从而导致内存消耗完或者"过度切换"的问题

    • 在获取t线程执行结果的时候，当前线程受阻塞，效率较低。

  • MyCallable类

    package com.test.multithreading;
​
import java.util.concurrent.Callable;
​
/**
 * @author welcome
 */
public class MyCallable implements Callable {
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 1; i <=100; i++) {
            if (i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }
}
    ​

  • 测试类

    package com.test.dy;
​
import com.test.multithreading.MyCallable;
​
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
​
/**
 * @author welcome
 */
public class Demo03 {
    public static void main(String[] args) {
​
        MyCallable myCallable=new MyCallable();
​
        FutureTask futureTask=new FutureTask<>(myCallable);
​
        new Thread(futureTask).start();
​
        try {
            Object sum = futureTask.get();
            System.out.println("总合：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
​
    }
}

  • Future接口

    • 可以对具体Runnable、Callable任务的执行结果进行取消、查询是 否完成、获取结果等。

    • FutrueTask是Futrue接口的唯一的实现类。

    • FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

4.通过线程池进行实现

  • Executors创建线程常用的4种方法

    • 公共类

      package com.test.multithreading.executorsandpool;
import java.util.concurrent.atomic.AtomicInteger;
​
/**
 * @author welcome
 */
public class CreateThreadPollDemo {
    public static final int SLEEP_GAP=1000;
    public static class TargetTask implements Runnable{
        static AtomicInteger taskNo=new AtomicInteger(1);
        private String taskName;
        public TargetTask()
        {
            taskName="task-"+taskNo;
            taskNo.incrementAndGet();
        }
​
        @Override
        public void run() {
            System.out.println(taskName+" is doing...");
            try {
                Thread.sleep(SLEEP_GAP);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(taskName+" end...");
        }
    }
​
}
      ​

    • newSingleThreadExecutor创建“单线程化线程池”

      • 代码

        package com.test.dy.executorsandpooltest;
​
import com.test.multithreading.executorsandpool.CreateThreadPollDemo;
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
​
/**
 * @author welcome
 */
public class PoolTest1 {
    public static void main(String[] args) {
        ExecutorService pool=Executors.newSingleThreadExecutor();
        for(int i=0;i<3;i++)
        {
            pool.execute(new CreateThreadPollDemo.TargetTask());
            pool.submit(new CreateThreadPollDemo.TargetTask());
        }
        pool.shutdown();
​
    }
}

      • 特点

        • 单线程化的线程池中的任务是按照提交的次序顺序执行的

        • 只有一个线程的线程池

        • 池中的唯一线程的存活时间是无限的

        • 当池中的唯一线程正繁忙时，新提交的任务实例会进入内部的阻塞队列中，并且其阻塞队列是无界的

        • 适用场景：任务按照提交次序，一个任务一个任务地逐个执行的场景

    • newFixedThreadPool创建“固定数量的线程池

      • 代码

        package com.test.dy.executorsandpooltest;
​
import com.test.multithreading.executorsandpool.CreateThreadPollDemo;
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
​
/**
 * @author welcome
 */
public class PoolTest2 {
    public static void main(String[] args) {
        ExecutorService pool= Executors.newFixedThreadPool(3);//最多有三个线程同时执行
        for (int i = 0; i < 5; i++) {
            pool.execute(new CreateThreadPollDemo.TargetTask());
            pool.submit(new CreateThreadPollDemo.TargetTask());
        }
        pool.shutdown();
    }
}

         

      • 特点

        • 如果线程数没有达到“固定数量”，每次提交一个任务线程池内就创建一个新线程，直到线程达到线程池固定的数量

        • 线程池的大小一旦达到“固定数量”就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程

        • 在接收异步任务的执行目标实例时，如果池中的所有线程均在繁忙状态，新任务会进入阻塞队列中（无界的阻塞队列）

      • 适用场景：

        • 需要任务长期执行的场景

        • CPU密集型任务

      • 缺点：

        • 内部使用无界队列来存放排队任务，当大量任务超过线程池最大容量需要处理时，队列无限增大，使服务器资源迅速耗尽

    • newCachedThreadPool创建“可缓存线程池”

      • 代码

        package com.test.dy.executorsandpooltest;
​
import com.test.multithreading.executorsandpool.CreateThreadPollDemo;
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
​
/**
 * @author welcome
 */
public class PoolTest3 {
    public static void main(String[] args) {
        ExecutorService pool= Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            pool.execute(new CreateThreadPollDemo.TargetTask());
            pool.submit(new CreateThreadPollDemo.TargetTask());
        }
        pool.shutdown();
    }
}
        ​

      • 特点

        • 在接收新的异步任务target执行目标实例时，如果池内所有线程繁忙，此线程池就会添加新线程来处理任务

        • 线程池不会对线程池大小进行限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小

        • 如果部分线程空闲，也就是存量线程的数量超过了处理任务数量，就会回收空闲（60秒不执行任务）线程

      • 适用场景：

        • 需要快速处理突发性强、耗时较短的任务场景，如Netty的NIO处理场景、REST API接口的瞬时削峰场景

      • 缺点

        • 线程池没有最大线程数量限制，如果大量的异步任务执行目标实例同时提交，可能会因创建线程过多而导致资源耗尽

    • newScheduledThreadPool创建“可调度线程池”

      • 代码

        package com.test.dy.executorsandpooltest;
​
import com.test.multithreading.executorsandpool.CreateThreadPollDemo;
​
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
​
/**
 * @author welcome
 */
public class PoolTest4 {
    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService pool= Executors.newScheduledThreadPool(2);
        for(int i=0;i<2;i++)
        {
            pool.scheduleAtFixedRate(new CreateThreadPollDemo.TargetTask(), 0, 500, TimeUnit.MILLISECONDS);
            //参数1： task任务
            //参数2： 首次执行任务的延迟时间
            //参数3： 周期性执行的时间
            //参数4： 时间单位
​
        }
        Thread.sleep(3000);//主线程睡眠时间越长 周期次数越多
        pool.shutdown();
    }
}
        ​

      • 特性

        • 延时性

        • 周期性

      • 缺点

        • 线程数量无上界，会导致创建大量的线程，从而导致OOM(内存耗尽)

    • newFixedThreadPoolnewSingleThreadExecutor阻塞队列无界，会堆积大量任务导致OOM(内存耗尽)
      newCachedThreadPoolnewScheduledThreadPool线程数量无上界，会导致创建大量的线程，从而导致OOM

  • ThreadPoolExecutor创建线程

    • 参数介绍

      corePoolSize核心线程池的大小。
      maximumPoolSize最大线程池的大小。
      keepAliveTime线程池维护线程所允许的空闲时间
      unit线程池维护线程所允许的空闲时间的单位
      workQueue用来暂时保存任务的工作队列。
      handler线程池对拒绝任务的处理策略
      threadFactory线程工厂

    • 代码

      import java.io.IOException;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
​
public class ThreadPoolExecutorTest {
​
    public static void main(String[] args) throws IOException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 10, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4), new NameTreadFactory(), new MyIgnorePolicy());
​
        // 预启动所有核心线程
        executor.prestartAllCoreThreads(); 
​
        for (int i = 1; i <= 10; i++) {
            MyTask task = new MyTask(String.valueOf(i));
            executor.execute(task);
        }
        
        //阻塞主线程
        System.in.read(); 
    }
​
    static class NameTreadFactory implements ThreadFactory {
​
        private final AtomicInteger mThreadNum = new AtomicInteger(1);
​
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }
​
    public static class MyIgnorePolicy implements RejectedExecutionHandler {
​
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            doLog(r, e);
        }
​
        private void doLog(Runnable r, ThreadPoolExecutor e) {
            System.err.println(r.toString() + " rejected");
            System.out.println("completedTaskCount: " + e.getCompletedTaskCount());
        }
    }
​
    static class MyTask implements Runnable {
        private String name;
​
        public MyTask(String name) {
            this.name = name;
        }
​
        @Override
        public void run() {
            try {
                System.out.println(this.toString() + " is running!");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
​
        public String getName() {
            return name;
        }
​
        @Override
        public String toString() {
            return "MyTask [name=" + name + "]";
        }
    }
}

    • 优点

      • 降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗

      • 提高响应速度，当任务到达时任务不需要等到线程创建就能立即执行

      • 提高线程的可管理性，使用线程池进行统一的分配，调优和监控

 

奏长歌，踏山河
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mybaits 多线程 实现数据批量插入 （运用CountDownLatch实现闭锁）
10-12
mybaits 多线程 实现数据批量插入 （运用CountDownLatch实现闭锁） 1、mybatis批处理 2、数据分批量查询 3、数据分批量插入
java-多线程
hzx790688184的博客
11-20 113
多线程的几种状态和方法 线程和线程安全 本篇主要整理了之前关于线程的部分笔记 什么是线程 首先我们的电脑可以同时（没有感知）运行多个程序，一个程序通常有一个或以上的进程，进程里面又包括一个或以上的线程，线程即是一个具体的执行单元 线程的状态（生命周期） 新建:创建一个线程，Thread myThread = new Thread(); 就绪:启动线程，等待通过线程调度获取cpu资源，myThread.start(); 运行:就绪状态的线程获取了cpu的资源，run(); 阻塞: – 等待阻塞：wait()
java创建线程的三种方式
weixin_45135517的博客
06-07 266
java线程 创建和运行线程 方法一，直接使用 Thread // 创建线程对象 Thread t = new Thread() { public void run() { // 要执行的任务 } }; // 启动线程 t.start(); 例如： // 构造方法的参数是给线程指定名字，推荐 Thread t1 = new Thread("t1") { @Override // run 方法内实现了要执行的任务 public void run() { log.debug("hello");
C++多线程实现电子词典
01-20
本文实例为大家分享了C++多线程实现电子词典的具体代码，供大家参考，具体内容如下 // Dictionary.cpp : 定义控制台应用程序的入口点。 //vs2013编译 //字典文件:https://pan.baidu.com/s/1YHtwptaq_V8j034U9_J96A #include stdafx.h #include <string> #include <vector> #include <iostream> #include <map> #include <fstream> #include <io> #include <thread> #include <tim
Java程序员之创建多线程的几种方式（三种方式、七种方法）
weixin_56610646的博客
11-01 1474
1.如果你是jdk1.8和之后的版本，不需要返回值的话可以考虑用lambda表达式来创建新线程2.如果需要返回值可以考虑用最后一种方法匿名callable接口。
多线程代码实现
q322359的博客
07-22 179
多线程代码实现
多线程的三种实现代码
yuxialuozi的博客
07-09 537
该类实现了Runnable接口，并重写了run()方法，在其中编写线程的任务逻辑。在上述代码中，我们定义了一个自定义线程类MyThread，该类继承了Thread类，并重写了Thread类的run()方法。需要注意的是，在多线程编程中，不要直接调用run()方法，而是通过start()方法来启动线程，因为直接调用run()方法只会在当前线程中以普通方法的方式执行，而不会启动一个新的线程。需要注意的是，在使用实现Runnable接口的方式时，线程的任务逻辑必须在run()方法中实现，而不是直接在类中编写。
实现多线程定义执行多种方式代码示例
还在活水泥的未来包工头
03-03 206
以上是几种常见的实现多线程的方式的代码示例，每种方式都有其特点和适用场景，开发人员可以根据具体需求选择合适的方式。实现多线程多种方式代码示例。
Java 多线程介绍及实现
敲代码的小李同学的博客
10-24 447
Java 多线程介绍及实现
【并发编程】多线程先执行完的先取结果的解决方案：CompletionService
qq_35436158的博客
02-20 682
多线程一边生成任务,一边获取任务的返回值，让等待时间短的线程优先返回结果，这就是CompletionService。
多线程实现源代码（简单）
04-20
可以了解多线程之间是怎么运行的。下面的程序验证两个纯程的执行是同时执行的，在单处理器系统上，线程的同时执行需要CPU在线程之间的快速切换来实现。
java多线程的两种实现
08-18
线程的概念及简单实现博客源代码。想要学习更多有关于Java多线程的知识，请关注博客http://blog.csdn.net/yegongheng
c#实现多线程代码例子
11-27
相信大家都有用过网际快车等下载资源的经历，它里面是可以设置线程数的（近年版本默认是10，曾经默认是5）。它会将文件分成与线程数相同的部分，然后每个线程下载自己的那一部分，这样下载效率就有可能提高。相信大家都有加多线程数，提升下载效率的经历。但细心的用户会发现，在带宽一定的情况下，并不是线程越多，速度越快，而是在某一点达到峰值。
多线程两种实现方式Java
07-28
多线程两种实现方式Java，MLDN,实训课程中的多线程
简单了解Java多线程实现的四种方式
08-19
主要介绍了简单了解Java多线程实现的四种方式,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java多线程实现同时输出
09-02
主要介绍了Java多线程实现同时打印的相关资料,需要的朋友可以参考下
Java多线程实现四种方式原理详解
12-17
2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target 3.通过Callable和FutureTask创建线程 4.通过线程池创建线程 前面两种可以归结为一类：无返回值，原因很简单，...
实现多线程的三种方式
weixin_44525106的博客
08-30 558
多线程在实际开发中应用很多，下面给大家简单介绍一下实现多线程的三种方式废话不多说，直接上代码~
Java创建多线程的五种写法
qq_62718027的博客
06-21 1982
其实就是在Thread里面多了一个new Runnable。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)
java 多线程实现
最新发布
02-24
Java多线程实现可以通过以下几种方式： 1. 继承Thread类：创建一个继承自Thread类的子类，并重写run()方法，在run()方法中定义线程的执行逻辑。然后通过创建该子类的对象，并调用start()方法来启动线程。 2. 实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值