多线程并发库（一）

最新推荐文章于 2024-08-04 10:35:57 发布
最新推荐文章于 2024-08-04 10:35:57 发布
阅读量1.1k 收藏
点赞数 1
分类专栏： ----------java java多线程学习 文章标签： 多线程 并发 线程 库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011521890/article/details/53388915
版权

ThreadLocal

是线程局部变量。在多线程中，实现每个线程中变量的私有性。

例子一

在该例子中，在同一个线程中通过调用类A和类B的getData()方法获取的数据是一致的。

public class ThreadLocalTest {
static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
public static void main(String[] args) {
    final ThreadLocalTest tlt = new ThreadLocalTest();
    for(int i=0;i<3;i++){
        new Thread(new Runnable() {
            @Override
            public void run() {
                int data = new Random().nextInt();
                threadLocal.set(data);
                System.out.println(Thread.currentThread().getName()+"==生成的数据是："+data);
                tlt.new A().getData();
                tlt.new B().getData();
            }
        }).start();
    }
}
class A{
    public void getData(){
        System.out.println(Thread.currentThread().getName()+"A:"+"取出的数据是："+threadLocal.get());
    }
}
class B{
    public void getData(){
        System.out.println(Thread.currentThread().getName()+"B:"+"取出的数据是："+threadLocal.get());
    }
}

** }
结果：**

Thread-1==生成的数据是：-229198565
Thread-2==生成的数据是：-1892334218
Thread-0==生成的数据是：-1126013147
Thread-0A:取出的数据是：-1126013147
Thread-1A:取出的数据是：-229198565
Thread-2A:取出的数据是：-1892334218
Thread-1B:取出的数据是：-229198565
Thread-2B:取出的数据是：-1892334218
Thread-0B:取出的数据是：-1126013147

例子二

实现每个线程只拥有一个实例对象的写法。

public class ThreadLocalForObjTest {
static ThreadLocal<Student> threadLocal = new ThreadLocal<>();
public static void main(String[] args) {
    final ThreadLocalForObjTest tlt = new ThreadLocalForObjTest();
    for(int i=0;i<3;i++){
        new Thread(new Runnable() {
            @Override
            public void run() {
                int data = new Random().nextInt(150);
                Student s = Student.getInstance();
                s.setAge(data);
                s.setName("lzl"+data);
                threadLocal.set(s);
                System.out.println(Thread.currentThread().getName()+"==生成的数据是："+data);
                tlt.new A().getData();
                tlt.new B().getData();
            }
        }).start();
    }
}
class A{
    public void getData(){
        System.out.println(Thread.currentThread().getName()+"A:"+"取出的数据是："+threadLocal.get().toString());
    }
}
class B{
    public void getData(){
        System.out.println(Thread.currentThread().getName()+"B:"+"取出的数据是："+threadLocal.get().toString());
    }
}
}
class Student{
private String name;
private int age;
private static ThreadLocal<Student> map = new ThreadLocal<Student>();
public static Student getInstance(){
    Student instance = map.get();
    if(instance ==null){
        instance = new Student();
        map.set(instance);
        System.out.println("======显示次数========");
    }
    return instance;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
@Override
public String toString() {
    return "Student [name=" + name + ", age=" + age + "]";
}
}

结果
三个线程，创建了三个实例对象。并且保证单个线程中的数据是私有的。

======显示次数========
======显示次数========
======显示次数========
Thread-0==生成的数据是：81
Thread-1==生成的数据是：67
Thread-2==生成的数据是：81
Thread-2A:取出的数据是：Student [name=lzl81, age=81]
Thread-0A:取出的数据是：Student [name=lzl81, age=81]
Thread-1A:取出的数据是：Student [name=lzl67, age=67]
Thread-1B:取出的数据是：Student [name=lzl67, age=67]
Thread-0B:取出的数据是：Student [name=lzl81, age=81]
Thread-2B:取出的数据是：Student [name=lzl81, age=81]

多线程中共享数据

  1. 如果代码块执行的逻辑相同，可以在一个继承Runnable的类中实现数据的共享。
    两个线程之间共享了count数据

    public class MultiThreadShareData {
public static void main(String[] args) {
    MyRunnable mr = new MyRunnable();
    new Thread(mr).start();
    new Thread(mr).start();
}
static class MyRunnable implements Runnable{
    private int count=5;
    @Override
    public void run() {
        while(true){
            System.out.println("线程名："+Thread.currentThread().getName()+" count="+count);
            if(count<1){
                break;
            }
            dec();
        }

    }
    private synchronized int dec(){
        count--;
        return count;
    }
}
}

结果：

线程名：Thread-0 count=5
线程名：Thread-1 count=5
线程名：Thread-0 count=4
线程名：Thread-1 count=3
线程名：Thread-1 count=1
线程名：Thread-0 count=2
线程名：Thread-1 count=0

  1. 如果代码块不同，就将数据封装到同一个对象中，将这个对象逐一传递给每个Runnable对象。
    两个线程之间共享了data数据 

    public class MultiThreadShareData2 {
public static void main(String[] args) {
    new MultiThreadShareData2().init();
}
private void init(){
    new Thread(new DecRunnable(this)).start();
    new Thread(new IncRunnable(this)).start();
}
int data=10;
private synchronized void dec(){
data--;
    System.out.println(Thread.currentThread().getName()+" data Dec="+data);
}
private synchronized void inc(){
    data++;
    System.out.println(Thread.currentThread().getName()+" data Inc="+data);
}
static class DecRunnable implements Runnable{
    private MultiThreadShareData2 data;
    public DecRunnable(MultiThreadShareData2 data2){
        this.data = data2;
    }
    @Override
    public void run() {
        while(true){
            data.dec();
        }
    }
}
static class IncRunnable implements Runnable{
    private MultiThreadShareData2 data;
    public IncRunnable(MultiThreadShareData2 data2){
        this.data = data2;
    }
    @Override
    public void run() {
        while(true){
            data.inc();
        }
    }
}
}

Executors的应用

  1. 创建固定大小的线程池

    ExecutorService fixedThreadPools = Executors.newFixedThreadPool(5);

  2. 创建缓存线程池

    ExecutorService threadPools = (ExecutorService) 
            Executors.newCachedThreadPool();

  3. 创建单一线程池（保证内存中一直有一条线程）

    ExecutorService sigleThreadPools = Executors.newSingleThreadExecutor();

  4. 线程池启动定时器

    ScheduledExecutorService threadPools = (ScheduledExecutorService) Executors.newScheduledThreadPool(3); //创建一个计时器的线程
    threadPools.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            System.out.println("hhh");
        }
    }, 2, 2, TimeUnit.SECONDS);
}

    例子：

    public class ExecutorsTest {
public static void main(String[] args) {
    ExecutorService threadPools = (ExecutorService) 
            Executors.newCachedThreadPool();//创建缓存线程池。线程的大小没有固定
    ExecutorService fixedThreadPools = Executors.newFixedThreadPool(5);//创建固定大小的线程池
    ExecutorService sigleThreadPools = Executors.newSingleThreadExecutor();//创建
    for(int i=0;i<10;i++){
        final int task = i;
        fixedThreadPools.execute(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    System.out.println("线程名："+Thread.currentThread().getName()+" 循环了"+i+"次，第"+task+"任务");
                }
            }
        });
    }
    System.out.println("循环结束...");
    new ExecutorsTest().hh();
}

Callable和Future

  1. 通过Executors的submit方法获取线程中返回的结果。

    public class CallableAndFuture {
public static void main(String[] args) {
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    Callable<String> callable = new Callable<String>() {
        @Override
        public String call() throws Exception {
            Thread.sleep(2000);
            return "Hello Thread!";
        }
    };
    Future<String> future = executorService.submit(callable);
    System.out.println("等待结果...");
    try {
        System.out.println("结果是："+future.get(1,TimeUnit.SECONDS)); //1s后没有拿到结果，就抛错！
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}
}

  2. CompletionService提交多组数据

    private void futureTest2(){
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    CompletionService<Integer> completionService = new ExecutorCompletionService(executorService);
    for(int i=0;i<10;i++){
        final int task=i;
        completionService.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                Thread.sleep(new Random().nextInt(5000));
                return task;
            }
        });
    }
    for(int i=0;i<10;i++){
        try {
            System.out.println("结果是："+completionService.take().get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
阿卧
关注
专栏目录
OpenThreads线程库
07-29 4322
OpenThreads与pthread不同点在于，他是根据面向对象开发的。 一、OpenThreads在线程同步上不同于之前我所了解的（比如pthread），除了常用的几路，他还提出了额外的。 传统的： 1. 互斥量OpenThreads::Mutex类 当线程使用某一资源时，先使用互斥量加锁。由于采用了面向对象机制将互斥量抽象为一个类，所以不像pthread函数那样传入个参数。Mutex
基于Qt的多线程并发服务器
08-03
"基于Qt的多线程并发服务器"是一个典型的解决方案，它利用了Qt库的强大功能，特别是其对多线程的支持，来处理来自多个客户端的并发请求。下面我们将深入探讨这个主题。 首先，Qt是一个跨平台的应用程序开发框架，...
多线程及线程并发库
何毅
07-24 1537
1. 创建和启动线程的两种传统方式概念：java 实现一条线索 有两种方法： 1、继承thread 类 例子： // 继承Thread类 new Thread(){ publicvoid run(){ while(true){ try { Thread
【C++】线程库
最新发布
℉f的博客
08-04 930
语言可以使技术具有跨平台性，在C++11提供线程库之前，由于线程在不同操作系统下实现的方式各不相同，比如Windows和Linux下各有自己的接口，这使得代码的可移植性比较差，为了解决这一问题，C++11引入了线程库，使用该线程库并不需要依赖第三方库（-lpthread）。
Python 多线程库总结
weixin_30237281的博客
09-12 206
多线程库总结基于线程的并行性threading模块下面是一些基础函数，函数包括：函数threading.active_count()threading.current_thread()threading.get_ident()threading.enumerate()threading.main_thread()threading.settrace(func)threading.setprofil...
线程并发库
u013432486的专栏
05-13 568
线程并发库
多线程和并发库相关
change的博客
03-14 2102
（一）多线程基础知识--传统线程机制的回顾    (1)传统使用类Thread和接口Runnable实现      1.在Thread子类覆盖的run方法中编写运行代码new Thread(){     @Override     public void run(){         while(true){             try {                 Thread.sle...
Java多线程与并发库高级应用
08-16
并发库高级应用\多线程\Java
Java多线程与并发库视频资源网盘链接
04-11
Java多线程与并发库是Java开发者必备的重要技能之一，尤其对于处理高并发场景的应用开发至关重要。本视频资源集合旨在帮助初级开发人员深入理解和掌握这一关键领域，通过学习，你可以提升自己的程序性能优化能力，更...
Java多线程与并发库高级应用视频教程22集
07-22
资源名称：Java多线程与并发库高级应用视频教程22集资源目录：【】01传统线程技术回顾【】02传统定时器技术回顾【】03传统线程互斥技术【】04传统线程同步通信技术【】04传统线程同步通信技术_分割纪录【】05线程...
JDK5中的多线程并发库.doc
10-07
在JDK5中，Java引入了一套强大的多线程并发库，极大地提升了多线程编程的效率和安全性。这个库提供了丰富的类和接口，使得开发者能够更好地控制线程的执行、同步和通信。 1. **线程** - **线程与进程的关系**：...
多线程并发处理
huobengluantiao8
08-02 119
问题：在两路或三路同时回放同一个文件夹下的BMP图像时，由于两个或三个线程同时访问相同的数据而引发冲突，使线程意外终止。 解决方法：利用MFC提供的同步类和同步访问类。 同步类：CSyncObject, CSemaphore, CMutex, CCriticalSection ,CEvent； 同步类用于当访问资源时保证资源的整体性。其中CsyncObject 是其它四个同步类的基类，不直接...
多线程并发
三好市民江先生的博客
05-13 253
1.并发就是对共享资源同时进行访问，而产生的现象 2.线程的实现方式：继承Thread或实现runnable都要重写run方法。 3.启动线程是通过Thread的start（用户进程）方法实现的，如果直接调用run（守护进程）方法启动的线程和当前主线程是同时结束的。（守护线程会随主线程的结束而结束） 4.共享变量：多个线程对一个变量进行访问时，都是先从JMM（Java内存莫模型）主内存读取变量的值到自己的本地内存，等待线程运行结束后再把自己当前线程中本地变量的值刷回主内存，这样在多线程同时访问的情况下就会产
多线程、并发
PAPAPA
04-13 906
sleep()/wait()：sleep是Thread类的方法，是个静态方法，所以只对当前线程有效；wait是Object类的方法，需先获得对象的同步锁，也使当前线程可不运行。wait会释放对象的锁，线程挂起，直到被notify()才进入runnable同步静态方法，线程会获取该类的Class对象的锁。 死锁：多个线程无限阻塞，互相等待所需资源。 线程间通信？ Object类
JDK5多线程并发库详解：创建与同步方法
在JDK5中，多线程并发库提供了丰富的工具和API来支持高效的并发编程。首先，理解线程与进程的关系是关键：进程是一个运行中的程序，而线程则是程序执行过程中的独立执行单元，一个进程可以包含多个线程，它们共享...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值