线程高级应用-心得3-线程范围内的共享变量以及应用场景及面试题案例分析

1.知识点普及

2.案例说明：线程范围内的共享变量以及应用场景（转账，转入和转出）；在线程内共享，在线程外独立

package com.itcast.family;

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

/**
 * 案例说明：线程范围内的共享变量以及应用场景（转账，转入和转出）；在线程内共享，在线程外独立
 */
public class ThreadScopeShareData {

    //使不同模块拿到相同线程的相同数据
    private static Map<Thread,Integer> threadData = 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 data = new Random().nextInt();
                    System.out.println(Thread.currentThread().getName()
                            + " has put data: " + data);
                    threadData.put(Thread.currentThread(), 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().getName()
                    + " get data: " + data);
        }
    }

    static class B {
        public void get() {
            int data = threadData.get(Thread.currentThread());
            System.out.println("B from " + Thread.currentThread().getName()
                    + " get data: " + data);
        }
    }
}
3. 使用ThreadLocal达到与上个案例相同的需求
package com.itcast.family;

import java.util.Random;

/**
 * 使用ThreadLocal达到与上个案例相同的需求
 */
public class ThreadLocalTest {


    //使不同模块拿到相同线程的相同数据
    //直接使用ThreadLocal传入数据
    private static ThreadLocal<Integer> threadData = new ThreadLocal<Integer>();
    //使用ThreadLocal传入对象中封装的数据;普通思路用到的变量
    //private static ThreadLocal<MyThreadScopeData> myData = new ThreadLocal<MyThreadScopeData>();
    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();
                    System.out.println(Thread.currentThread().getName()
                            + " has put data: " + data);
                    threadData.set(data);
                    
                    //一般思路，符合基本的面向对象编程，但是用着啰嗦臃肿，代码不够优化    
/*                    MyThreadScopeData myThread = new MyThreadScopeData();
                    myThread.setName("get nameData: "+data);
                    myThread.setAge(data);
                    myData.set(myThread);*/
                    
                    
                    //优雅和优化的思路，类似单例模式封装代码，因为使用者只需知道怎么用干什么用的，而不需知道内部代码是什么
                    MyThreadScopeData.getThreadInstance().setName(" get nameData: "+data);
                    MyThreadScopeData.getThreadInstance().setAge(data);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }

    static class A {
        public void get() {
            int data = threadData.get();
            System.out.println("A from " + Thread.currentThread().getName()
                    + " get data: " + data);
    
            //一般思路，符合基本的面向对象编程，但是用着啰嗦臃肿，代码不够优化
/*            MyThreadScopeData myThread = myData.get();
            System.out.println("A from " + Thread.currentThread().getName()
                     + myThread.getName()+" ;get ageData: "+myThread.getAge());*/
            
            
            //优雅和优化的思路，类似单例模式封装代码，因为使用者只需知道怎么用干什么用的，而不需知道内部代码是什么
            MyThreadScopeData myThread = MyThreadScopeData.getThreadInstance();
            System.out.println("A from " + Thread.currentThread().getName()
                     + myThread.getName()+" ; get ageData: "+myThread.getAge());
        }
    }

    static class B {
        public void get() {
            int data = threadData.get();
            System.out.println("B from " + Thread.currentThread().getName()
                    + " get data: " + data);
            
/*            MyThreadScopeData myThread = myData.get();
            System.out.println("B from " + Thread.currentThread().getName()
                     + myThread.getName()+" ;get ageData: "+myThread.getAge());*/
            
            MyThreadScopeData myThread = MyThreadScopeData.getThreadInstance();
            System.out.println("B from " + Thread.currentThread().getName()
                     + myThread.getName()+" ; get ageData: "+myThread.getAge());
        }
    }
}

class MyThreadScopeData{
    //可以参考单例模式来编写更加优化和优雅的线程代码
    private MyThreadScopeData(){}
     //线程这里与单例有些许不同，因为只有一个对象，所以可以不用使用同步锁
    public static/*synchronized*/MyThreadScopeData getThreadInstance(){
        MyThreadScopeData instance = map.get();
        if(instance == null){
            instance = new MyThreadScopeData();
            map.set(instance);
        }
        return instance;
    }
    
    /*只是告诉阅读者类似单例代码，但是与单例不同
     * private static MyThreadScopeData intance = null;//new MyThreadScopeData(); 
    //饱汉式，不管用不用先new出来；这里用饿汉式，用的时候才new出来
    */    
    private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();
    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;
    }
    
}
4. 面试题： 设计4个成员，其中两个线程每次对j加1；另两个线程每次对j减1，代码如下分析：

package com.itcast.family;

/**
 * 面试题：
 *    设计4个成员，其中两个线程每次对j加1；
 * 另两个线程每次对j减1，代码如下分析：
 */
public class MultiThreadShareData {
    
    // 面试题答案：
    private int j;

    public static void main(String[] args) {
        MultiThreadShareData data = new MultiThreadShareData();
        Inc inc = data.new Inc();
        Dec dec = data.new Dec();
        //创建四个线程，如题：两个增加两个减少
        for (int i = 0; i < 2; i++) {
            new Thread(inc).start();
            new Thread(dec).start();
        }
    }

    /*
     * 不直接把j++或j--写到对应的实现Runnable类的代码中，
     * 而是抽出成外部类的两个方法；是因为外部类的方法方便使用
     * 同步锁，更容易控制并发问题
     */
    private synchronized void inc() {
        j++;
        System.out.println(Thread.currentThread().getName() + "-inc:" + j);
    }

    private synchronized void dec() {
        j--;
        System.out.println(Thread.currentThread().getName() + "-dec:" + j);
    }

    class Inc implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                inc();
            }
        }

    }

    class Dec implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                dec();
            }
        }

    }
    
    

    
    /*//第一种方案传入的data变量要么是静态成员变量要么是最终普通变量，否则会出错；因为两个内部类访问可以访问同一个外部类的成员变量
    private static ShareData data1 = new ShareData();
    public static void main(String[] args) {
        final ShareData data1 = new ShareData();
        ShareData data2 = new ShareData();
        
        //第一种方案：这两个线程分别实现两个Runnable的run方法，分别用来执行加减
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                data1.increment();
            }
        }).start();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                data1.decrement();
            }
        }).start();
        
        //第二种方案：传入实现了Runnable接口的类对象，相应的需求方法封装在传入的类中
        new Thread(new MyRunnable1(data2)).start();
        new Thread(new MyRunnable2(data2)).start();

    }

}

//第二种方案
class MyRunnable1 implements Runnable{
    private ShareData data;
    MyRunnable1(ShareData data) {
        super();
        this.data = data;
    }

    public void run() {
        data.increment();
    }
}
class MyRunnable2 implements Runnable{
    private ShareData data;
    MyRunnable2(ShareData data) {
        super();
        this.data = data;
    }
    
    public void run() {
        data.decrement();
    }
}


//因为需求是一个加一个减，即两个不同的线程，仅实现一个Runnable接口是不够的
class ShareData{ implements Runnable{
    private int count = 100;
    @Override
    public void run() {
        while(true){
            count --;
        }
    }
   
    private int j = 0;
    public void increment(){
        j++;
    }
    public void decrement(){
        j--;

    }
    */
}