多线程——线程范围内变量的共享

时间 2019-11-17

原文原文链接

线程范围内的共享变量是指对同一个变量，几个线程同时对它进行写和读操做，而同一个线程读到的数据就是它本身写进去的数据。java

一、未实现变量共享的demo：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package com.model.elgin.thread;

import java.util.Random;

public class NotSharedVarThread {

    private static int data;

    public static void main( String [] args) {


        for ( int i = 0 ; i < 2 ; i++) {
            new Thread( new Runnable() {

                @Override
                public void run() {
                        data= new Random().nextInt( 10000 );
                        System.out.println(Thread.currentThread().getName() + "将data修改成：" +data);
                        new A().get();
                        new B().get();
                }
            }).start();
        }

    }
    static class A{
        public void get(){
            System.out.println(Thread.currentThread().getName() + "-A类中data的值为：" + data);
        }
    }
    static class B{
        public void get(){
            System.out.println(Thread.currentThread().getName() + "-B类中data的值为：" + data);
        }
    }
}

运行结果：安全

从结果能够看出，线程0将线程1修改后的data值覆盖了，而且输出的结果是线程1中修改的值。dom

那么该如何来解决这个问题呢？ide

二、线程范围内变量共享的实现方式：

1、经过线程的同步互斥实现

使用同步代码块，将变量修改以及访问的代码加锁，线程0访问结束才容许线程1来修改data的值，代码以下：函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

package com.model.elgin.thread;

import java.util.Random;

public class NotSharedVarThread {

    private static int data;

    public static void main( String [] args) {


        for ( int i = 0 ; i < 2 ; i++) {
            new Thread( new Runnable() {

                @Override
                public void run() {
                    synchronized (NotSharedVarThread. class ) {
                        data= new Random().nextInt( 10000 );
                        System.out.println(Thread.currentThread().getName() + "将data修改成：" +data);
                        new A().get();
                        new B().get();
                    }
                }
            }).start();
        }

    }
    static class A{
        public void get(){
            System.out.println(Thread.currentThread().getName() + "-A类中data的值为：" + data);
        }
    }
    static class B{
        public void get(){
            System.out.println(Thread.currentThread().getName() + "-B类中data的值为：" + data);
        }
    }
}

运行结果：测试

从结果能够看出，线程1结束以后线程0才开始修改data的值。spa

2、经过Map的key/value键值对，将线程与其对应的数据绑定

经过Map的特性，将key为当前线程，value为对应的值。.net

测试代码：线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package com.model.elgin.thread;

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

public class NotSharedVarThread {

    private static Map<Thread,Integer> data= new HashMap<Thread, Integer>();

    public static void main( String [] args) {

        for ( int i = 0 ; i < 2 ; i++) {
            new Thread( new Runnable() {

                @Override
                public void run() {
                    int value= new Random().nextInt( 10000 );
                    data.put(Thread.currentThread(),value);
                    System.out.println(Thread.currentThread().getName()+ "将data中的值修改成：" + value);
                    new A().get();
                    new B().get();
                }
            }).start();
        }

    }
    static class A{
        public void get(){
            System.out.println(Thread.currentThread().getName() + "-A类中data的值为：" + data.get(Thread.currentThread()));
        }
    }
    static class B{
        public void get(){
            System.out.println(Thread.currentThread().getName() + "-B类中data的值为：" + data.get(Thread.currentThread()));
        }
    }
}

运行结果：对象

3、经过ThreadLocal实现：

ThreaLocal类在维护变量时，实际使用了当前线程（Thread）中的一个叫作 ThreadLocalMap的独立副本（Thread的成员变量），每一个线程能够独立的修改属于本身的副本而不会相互影响，从而实现了线程之间的隔离，避免了线程访问实例变量发生冲突的问题。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package com.model.elgin.thread;

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

public class NotSharedVarThread {

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

    public static void main( String [] args) {

        for ( int i = 0 ; i < 2 ; i++) {
            new Thread( new Runnable() {

                @Override
                public void run() {
                    int value= new Random().nextInt( 10000 );
                    data.set(value);
                    System.out.println(Thread.currentThread().getName()+ "将线程对应的value保存到ThreadLocal对象中" + value);
                    new A().get();
                    new B().get();
                }
            }).start();
        }

    }
    static class A{
        public void get(){
            System.out.println(Thread.currentThread().getName() + "-A类中data的值为：" + data.get());
        }
    }
    static class B{
        public void get(){
            System.out.println(Thread.currentThread().getName() + "-B类中data的值为：" + data.get());
        }
    }
}

运行结果：

三、小结

1） ThreadLocal是一个Java类，经过对当前线程中局部变量的操做来解决不一样线程的访问变量的冲突问题。因此，ThreadLocal提供了线程安全的共享机制，每一个线程都拥有各自的副本（ThreadLocalMap实例）

2） Java中的synchronized是一个关键字，它依靠JVM的锁机制来实现临界区的函数或者变量在访问时的原子性。在同步机制中，经过对象的锁机制来保证同一时刻只有一个线程访问变量。

同步机制采起了以“以时间换空间”的方式，提供一个变量，让线程排队访问。而ThreadLocal则是采用了以“空间换取时间”的方式，为每个线程都提供一份变量副本，从而实现同时访问而互不影响。