Fork me on GitHub

Java 多线程 - 续

发表于 | 更新于: | 分类于
字数统计: 1,607 | 阅读时长 ≈ 7

注意：所有文章除特别说明外，转载请注明出处.

多线程之共享数据

在这里主要总结线程共享数据的相关知识，主要包括两方面:一是某个线程内如何共享数据，保证各个线程的数据不交叉。二是多个线程间如何共享数据，保证数据的一致性。

1.线程范围内共享数据

当我们自己实现的话，是定义一个Map，线程为键，数据为值。表中的每一项即是为每个线程准备的数据，这样在一个线程中数据是一致的。

如：

package com.iot.thread;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
 * Created by brian on 2016/2/4.
 */
public class ThreadScopeShareData {
    //准备一个哈希表，为每个线程准备数据
    private  static Map<Thread,Integer> threadData = new HashMap<>();
    public static void main(String[] args) {
        for(int i=0;i<2;i++){
            new Thread(
                    new Runnable() {
                @Override
                public void run() {
                    int data = new Random().nextInt();
                    threadData.put(Thread.currentThread(),data);
                    System.out.println(Thread.currentThread()+" put data："+data);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }
   static  class A{
        public void get(){
            int data = threadData.get(Thread.currentThread());
            System.out.println("A from "+Thread.currentThread()+" get data "+data);
        }
    }

    static  class B{
        public void get(){
            int data = threadData.get(Thread.currentThread());
            System.out.println("B from "+Thread.currentThread()+" get data "+data);
        }
    }
}

上述代码偶尔会报异常：

Exception in thread "Thread-0" java.lang.NullPointerException
    at com.iot.thread.ThreadScopeShareData$A.get(ThreadScopeShareData.java:29)
    at com.iot.thread.ThreadScopeShareData$1.run(ThreadScopeShareData.java:21)
    at java.lang.Thread.run(Thread.java:745)

2.ThreadLocal类

API

java.lang:Class ThreadLocal<T>

  • 单变量 使用ThreadLocal类型的对象代替上面的Map即可

  • 多变量 定义一个对象来封装多个变量，然后在ThreadLocal中存储整个对象

多变量时，最好将ThreadLocal类放在数据类的内部，数据类采用单例模式，这样，新建对象和获取对象都会更方便，同时封装性更强。

示例代码:

package com.iot.thread;

import java.util.Random;

/**
 * Created by brian on 2016/2/4.
 */
public class ThreadLocalTest {
    private  static ThreadLocal<Integer> threadInger = new ThreadLocal<>();
    public static void main(String[] args) {
        for(int i=0;i<2;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int data = new Random().nextInt(100);
                    threadInger.set(data);
                    System.out.println(Thread.currentThread()+" put data："+data);
                    MyThreadScopeData.getThreadInstance().setName(Thread.currentThread().toString());
                    MyThreadScopeData.getThreadInstance().setAge(data%10);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }
    static  class A{
        public void get(){
            int data = threadInger.get();
            System.out.println("A from "+Thread.currentThread()+" get data "+data);
            MyThreadScopeData myThreadScopeData = MyThreadScopeData.getThreadInstance();
            System.out.println("A from "+myThreadScopeData);

        }
    }

    static  class B{
        public void get(){
            int data = threadInger.get();
            System.out.println("B from "+Thread.currentThread()+" get data "+data);
            MyThreadScopeData myThreadScopeData = MyThreadScopeData.getThreadInstance();
            System.out.println("B from "+myThreadScopeData);
        }
    }
}

/**
 * 将多变量封装起来的数据类
 * 单例模式，内置ThreadLocal类型变量
 */
class MyThreadScopeData{

    private MyThreadScopeData(){}

    private static ThreadLocal<MyThreadScopeData> data = new ThreadLocal<>();

    public static  MyThreadScopeData getThreadInstance(){
        MyThreadScopeData instance = data.get();
        if(instance == null){
            instance = new MyThreadScopeData();
            data.set(instance);
        }
        return instance;
    }



    private String name;
    private int age;
    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() {
        String reVal = super.toString()+"-{name,age}"+":{"+getName()+","+getAge()+"}";
        return reVal;
    }
}

3.多线程访问共享数据

这里的几种方式：

1.线程执行代码相同，使用同一Runnable对象，Runnable对象中有共享数据。
2.线程执行代码不同，将共享数据封装在另一对象中（操作数据的方法也在该对象完成），将这个对象逐一传递给各个Runnable对象。[本质：共享数据的对象作为参数传入Runnable对象]。
3.线程执行代码不同，将Runnable对象作为某一个类的内部类，共享数据作为这个外部类的成员变量（操作数据的方法放在外部类）。[本质:不同内部类共享外部类数据]

4.结合上两种方式，将共享数据封装在另一对象中（操作数据的方法也在该对象完成），该对象作为这个外部类的成员变量，将Runnable对象作为内部类。

最后一种方式的示例:
设计5个线程，其中三个线程每次对j增加1，另外两个线程对j每次减少1

package com.iot.thread;

/**
 * Created by brian on 2016/2/4.
 */
public class MutiThreadShareData {

    private static MutiShareData mutiShareData = new MutiShareData();

    public static void main(String[] args) {

        for(int i=0;i<3;i++){
            new Thread(
                    new Runnable() {
                        @Override
                        public void run() {
                            System.out.println(Thread.currentThread()+":{j from "+ mutiShareData.getJ()+" + to: "+mutiShareData.increment()+"}");
                        }
                    }
            ).start();
        }

        for(int i=0;i<2;i++){
            new Thread(
                    new Runnable() {
                        @Override
                        public void run() {
                            System.out.println(Thread.currentThread()+":{j from "+ mutiShareData.getJ()+" - to: "+mutiShareData.decrement()+"}");
                        }
                    }
            ).start();
        }
    }

}

/**
 * 将共享数据封装在另一对象中（操作数据的方法也在该对象完成）
 */
class MutiShareData{
    private int j = 0;
    public synchronized  int increment(){
        return  ++j;
    }
    public synchronized int  decrement(){
        return --j;
    }

    public synchronized int getJ() {
        return j;
    }

    public synchronized void setJ(int j) {
        this.j = j;
    }
}

多线程之线程并发库

这里主要概述java.util.concurrent包下的相关类和使用方法

Package java.util.concurrent

1.原子性操作类

java.util.concurrent.atomic包下的类:

Package java.util.concurrent.atomic

2.线程池

线程池的作用是用来管理线程，减少内存的消耗。

java.util.concurrent:Class Executors
2.1 常用线程池

几种常用的的生成线程池的方法：

newCachedThreadPool
newFixedThreadPool
newScheduledThreadPool
newSingleThreadExecutor
newSingleThreadScheduledExecutor

例子：newFixedThreadPool

ExecutorService threadPool = Executors.newFixedThreadPool(3);
for(int i=0;i<10;i++){
    threadPool.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    });
}

单线程newSingleThreadExecutor可用于重启

用线程池启动定时器

1.案例：类似Timer的定时执行

Executors.newScheduledThreadPool(3).scheduleAtFixedRate(
            new Runnable() {
                @Override
                public void run() {
                    System.out.println("ScheduledThreadPool "+Thread.currentThread().getName());
                }
            },3,1, TimeUnit.SECONDS
    );

2.案例：创建线程池

package cn.edu.xidian.B.Demo.Thread;

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

public class ThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(6);
        Runnable target = () -> {
            for (int i = 0; i < 100; i++){
                System.out.println(Thread.currentThread().getName() + "的i值为：" + i);
            }
        };

        //向线程中提交两个线程
        pool.submit(target);
        pool.submit(target);

        //关闭线程池
        pool.shutdown();
    }
}

3.Callable&Future

ExecutorService在Executor的基础上增加了一些方法，其中有两个核心的方法：

Future<?> submit(Runnable task)
<T> Future<T> submit(Callable<T> task)

注意：这两个方法都是向线程池中提交任务，它们的区别在于Runnable在执行完毕后没有结果，Callable执行完毕后有一个结果。这在多个线程中传递状态和结果是非常有用的。另外他们的相同点在于都返回一个Future对象。Future对象可以阻塞线程直到运行完毕（获取结果，如果有的话），也可以取消任务执行，当然也能够检测任务是否被取消或者是否执行完毕。

6.同步工具

Semaphore

类似占坑

CyclicBarrier

阶段性使进度一致

CountDownLatch

一人通知多人/多人通知一人

Exchanger

线程间数据交换，都到达则自然交换

本文标题:Java 多线程 - 续

文章作者:Bangjin-Hu

发布时间:2019年06月06日 - 09:22:26

最后更新:2020年03月29日 - 10:36:21

原始链接:http://bangjinhu.github.io/undefined/Java 多线程 - 续/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

Bangjin-Hu wechat
欢迎扫码关注微信公众号，订阅我的微信公众号.
坚持原创技术分享，您的支持是我创作的动力.
分享到： 收藏夹 复制网址 邮件 微信 QQ空间 腾讯微博 豆瓣 一键分享 更多