多线程

最新推荐文章于 2024-08-01 09:46:25 发布
原创 最新推荐文章于 2024-08-01 09:46:25 发布 · 284 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了Java中线程的多种实现方式，包括通过继承Thread类、实现Runnable接口及使用Callable与Future。此外，还详细讲解了如何利用ReentrantLock进行同步控制、使用ReadWriteLock实现读写分离以及通过Exchanger进行线程间数据交换。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、线程的实现方式

     1.1、继承Thread类

public class ThreadImplementation extends Thread{
    
    @Override
    public void run() {
        System.out.println("线程实现方式之继承Thread类......" + Thread.currentThread().getName());
    }
    
    public static void main(String[] args) {
        new ThreadImplementation().start();
    }
    
}

  1.2、实现Runnable接口

public class RunnableImplementation implements Runnable{

    @Override
    public void run() {
        System.out.println("线程实现方式之实现Runnable接口......" + Thread.currentThread().getName());
    }
    
    public static void main(String[] args) {
        new Thread(new RunnableImplementation()).start();
    }
    
}

 1.3、有返回值的实现方式

public class CallableAndFutureTest {
    
    public static void main(String[] args) throws Throwable {
        Date start = new Date();
//        创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        List<Future> futures = new ArrayList<Future>();
        for(int i = 0; i < 3; i++){
            Callable callable = new MyCallable(i + "");
            Future future = executorService.submit(callable);
            futures.add(future);
        }
        executorService.shutdown();
        System.out.println("打印返回信息");
        for(Future future : futures){
            System.out.println(">>>" + future.get().toString());
        }
        Date end = new Date();
        System.out.println("耗时:" + (end.getTime() - start.getTime()));
    }
}

class MyCallable implements Callable<Object>{

    private String num;

    MyCallable(String num) {
        this.num = num;
    }
    
    @Override
    public Object call() throws Exception {
        System.out.println(">>>运行" + num +"任务开始");
        System.out.println("do something......" + num);
        System.out.println(">>>运行" + num +"任务结束");
        return num + "完成!";
    }
    
}

1.3.1、CallableAndFutureTest2

public class CallableAndFutureTest2 {
    
    public static void main(String[] args) throws Throwable{
        //返回一个线程池（这个线程池只有一个线程）
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<String> future = executorService.submit(new Callable<String>() {

            @Override
            public String call() throws Exception {
                return "Hello";
            }
        });

       executorService.shutdown();

        System.out.println(future.get());
    }
}

 1.3.2、CallableAndFutureTest3

public class CallableAndFutureTest3 {
    
    public static void main(String[] args) throws Throwable{
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CompletionService<Integer> completionService = new ExecutorCompletionService<>(executorService);
        for(int i = 0; i < 3; i ++){
            final int seq = i;
            completionService.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    return seq;
                }
            });
        }
        for(int i = 0; i < 3; i ++){
            System.out.println(completionService.take().get());
        }
    }
}

2、锁


public class LockTest {
    
    public static void main(String[] args) {
        new LockTest().init();
    }
    
    private void init() {
        final Outputer outputer = new Outputer();
        for (int i = 0; i < 30; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    outputer.output("AAAAA");
                }
            }).start();
        }
        
        for (int i = 0; i < 30; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    outputer.output("BBBBB");
                }
                
            }).start();
        }
    }
    
    static class Outputer {
        Lock lock = new ReentrantLock();
        
        public void output(String name) {
            int len = name.length();
            lock.lock();
            try {
                for (int i = 0; i < len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
            finally {
                lock.unlock();
            }
        }
    }
    
}


public class ReadWriteLockTest {
    
    public static void main(String[] args) {
        final Queue queue = new Queue();
        //写数据
        new Thread(){
            @Override
            public void run() {
                queue.put(new Random().nextInt(10000));
            }
            
        }.start();
        //读数据
        new Thread(){
            @Override
            public void run() {
                queue.get();
            }
        }.start();
        
    }
    
}


class Queue{
    ////共享数据，只有一个线程能够写该数据，但是可以多个线程可以读该线程
    private Object data;
    //读写锁
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    //写数据
    public void put(Object data){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "正准备写数据!");
            Thread.sleep((long)Math.random() * 1000);
            this.data = data;
            System.out.println(Thread.currentThread().getName() + "已经写完数据data:"  + data);
        }
        catch (InterruptedException e) {
        }finally{
            readWriteLock.writeLock().unlock();
        }
    }
    //读数据
    public void get(){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "正准备读取数据!");
            Thread.sleep((long)Math.random() * 1000);
            System.out.println(Thread.currentThread().getName() + "已经读取到数据data:"  + data);
        }
        catch (InterruptedException e) {
        }finally{
            readWriteLock.readLock().unlock();
        }
    }
}
3、数据交换

public class ExchangerTest {
    
    public static void main(String[] args) throws Throwable {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Exchanger exchanger = new Exchanger();
        
        executorService.execute(new Runnable() {
            
            @Override
            public void run() {
                try {
                    String sendData = "A发送的数据";
                    System.out.println("线程:" + Thread.currentThread().getName() + "正准备把数据\t" + sendData + "\t换出去");
                    Thread.sleep((long) Math.random() * 10000);
                    String returnData = (String) exchanger.exchange(sendData);
                    System.out.println("线程:" + Thread.currentThread().getName() + "\t换回的数据\t" + returnData);
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        executorService.execute(new Runnable() {
            
            @Override
            public void run() {
                try {
                    String sendData = "B发送的数据";
                    System.out.println("线程:" + Thread.currentThread().getName() + "正准备把数据\t" + sendData + "\t换出去");
                    Thread.sleep((long) Math.random() * 10000);
                    String returnData = (String) exchanger.exchange(sendData);
                    System.out.println("线程:" + Thread.currentThread().getName() + "\t换回的数据\t" + returnData);
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
        });
        
    }
    
}

4、定时器

     public class TimerTaskTest {
    
    private static int count = 0;
    
    public static void main(String[] args) {
        new Timer().schedule(new MyTimerTask(), 2000);
        while(true){
            System.out.println(new Date().getSeconds());
            try {
                Thread.sleep(1000);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class MyTimerTask extends TimerTask{

        @Override
        public void run() {
                count = (count + 1) %2;
                System.out.println("爆炸......");
                new Timer().schedule(new MyTimerTask(), 2000 + 2000 * count);
        }
        
    }
    
}

public class TimerTaskTest2{
    
    public static void main(String[] args) {
        Executors.newScheduledThreadPool(3).scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("爆炸......");
            }
            
        }, 4, 2, TimeUnit.SECONDS);
        
        while (true) {
            System.out.println(new Date().getSeconds());
            try {
                Thread.sleep(1000);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
    }
    
}


c#多线程
类人_猿的博客
12-26 3105
总结一下同步方法和异步方法的区别：1、同步方法由于主线程忙于计算，所以会卡住界面。异步方法由于主线程执行完了，其他计算任务交给子线程去执行，所以不会卡住界面，用户体验性好。2、同步方法由于只有一个线程在计算，所以执行速度慢。异步方法由多个线程并发运算，所以执行速度快，但并不是线性增长的（资源可能不够）。多线程也不是越多越好，只有多个独立的任务同时运行，才能加快速度。3、同步方法是有序的。异步多线程是无序的：启动无序，执行时间不确定，所以结束也是无序的。
异步处理优化：多线程线程池与消息队列的选择与应用
最新发布
张彦峰的博客
12-01 169万+
本文讨论了两种常见的异步处理方式：多线程线程池和消息队列（MQ）。通过将非核心逻辑异步化，可以提升系统的性能和响应速度。多线程线程池适用于本地并发任务，适合需要快速响应的场景，但无法处理跨服务任务。消息队列则适用于分布式系统，能够解耦服务并保证任务的可靠性和顺序性，适合处理高并发和高可靠性要求的任务。文章提供了实际代码示例，帮助开发者根据业务需求选择合适的异步处理方式。
java线程面试题_2019java面试题库
技术研究中心
05-23 505
1、15个Java线程并发面试题和答案 2、15个高级Java多线程面试题及回答 3、GC线程是否为守护线程？ 4、HashMap 是线程安全的吗，为什么不是线程安全的 5、Java中如何获取到线程dump文件 6、Java中实现线程通信的三个方法的作用是什么？ 7、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspe...
Java程序设计——多线程机制课后习题答案
INFINITY
11-24 5949
[Java]Chapter12多线程机制——课后习题答案 教材为：Java程序设计精编教程（第3版） 第12章——Java多线程机制 课后习题11： 张某、李某和赵某买电影票，售票员只有三张5元的钱，电影票5元钱一张。张某拿20元一张的人民币排在李某的前面买票，李某排在赵某的前面拿一张10元的人民币买票，赵某拿一张5元的人民币买票。 test11_Main.java package test11...
java 多线程 笔试题
哈哈__哈哈的专栏
08-07 281
1、4线程，2个对i加，2个对i减   2、实现孙线程跑5次，子线程跑10次，主线程跑15次。 代码：http://hongmin118.iteye.com/admin/blogs/2097489   3、编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推 代码：ht...
高级编程技术第五次作业、
m0_37660912的博客
03-25 177
5-6 人生的不同阶段ages = [1, 2, 4, 13, 20, 65] for age in ages: if age &lt; 2: print('He is a baby.') elif age &lt; 4: print('He is learing to walk.') elif age &lt; 13: print('He is a child.') elif...
java多线程
m0_46702681的博客
06-19 2524
javajava。
C++多线程
weixin_43229348的博客
04-17 3441
1.基础知识 为了提高CPU的使用率，将某些需要耗时较多的任务或是大量IO操作（IO处理速度很慢），采用多线程可以适当的提高程序的执行效率。 C++11之后有了std::thread库，需要引入头文件： 先来介绍Thread的成员函数： # 用来查看当前线程的id thread::get_id() # 检查此线程是否还和主线程连接（已经完成join、detach的线程都是false） thread：：joinable() # 将线程与主线程的连接切断，并且此线程会继续独立执行下去，直到执行结束时候释放分配的
C++多线程常用的几种实现方式
qq_41920323的博客
08-01 2470
C++多线程常用的几种实现方式
C语言多线程操作
技无涯的博客
11-27 1万+
C语言多线程操作 目录 C语言多线程 创建线程 终止线程 注意 信号量机制 参考博文： 返回目录 C语言多线程 多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下，两种类型的多任务处理：基于进程和基于线程。 基于进程的多任务处理是程序的并发执行。 基于线程的多任务处理是同一程序的片段的并发执行。 多线程程序包含可以同时运行...
【多线程与高并发】- 浅谈volatile
qq_43843951的博客
02-24 22万+
volatile是Java语言中的一种轻量级的同步机制，它可以确保共享变量的内存可见性，也就是当一个线程修改了共享变量的值时，其他线程能够立即知道这个修改。
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
RPC底层实现
看图说话
04-02 1323
1、基本原理 RPC底层原理: 服务端:暴露一个服务接口，整个接口中方法逻辑实现 暴露服务接口: Map<String,Object> key:暴露服务接口的名称 value:这个接口对应的实现类的实例 通过客户端传入的接口名称获取暴露服务列表中的接口实例，通过反射调用对应方法 客户端:调用暴露一个服务接口，不用管整个接口的具体实现逻辑，只管调用获取相应结果就ok 接口能直接调用:...
并发编程知识
看图说话
05-05 534
1、线程基础、线程之间的共享和协作 1.1、基础概念 1.1.1、cpu核心数、线程数 ​ cpu的核心数与线程数是1:1的关系,例如一个8核的cpu支持8个线程同时运行。但在intel引入超线程技术以后,关系就是1:2。在开发过程中并没有感觉到线程的限制,那是因为cpu时间片轮转机制(RR调度)的算法的作用。 1.1.2、cpu时间片轮转机制 ​ cpu给每个进程分配一个“时间段”，这...
java-rmi（060701）
看图说话
08-16 335
1、 相关类 package com.rmijava.test; import java.rmi.Remote; import java.rmi.RemoteException; /**  * 定义一个远程接口，必须继承Remote接口，其中需要远程调用的方法必须抛出RemoteException异常  * @author Administrator  *  */ pu
java枚举
看图说话
08-16 306
public enum Type {     STATUS_0(0,"禁用"),STATUS_1(1,"启动");     private Integer code;     private String desc;          private Type(Integer code, String desc) {         this.code = code;        
QT多线程编程示例详解
标题“QT的多线程编程示例”指的是关于使用QT（一种跨平台的C++图形用户界面应用程序开发框架）进行多线程编程的示例。多线程是编程中一种技术，允许一个程序同时执行两个或两个以上的部分，这些部分可以并行运行，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值