多线程范围内的数据共享

多线程范围内的共享解决方法参考有4中：

1.如果线程执行的代码相同，多个线程共享同一个runnable对象时，将共享数据放在runnable对象

2.如果多个线程执行的代码不同，将共享数据封装到一个对象中，将这个对象逐一传递给各个runnable对象

3.如果多个线程执行的代码不同，将共享数据作为外部类的final成员变量，将不同的runnable对象作为内部类主动取数据

4.将数据声明为static的方式（）

见如下示例：

1.如果线程执行的代码相同，多个线程共享同一个runnable对象时，将共享数据放在runnable对象

public class MuiltThreadShare {
    /**
     * 多个线程共享数据方法：
     * 1.如果线程执行的代码相同，多个线程共享同一个runnable对象时，将共享数据放在runnable对象
     * 2.如果多个线程执行的代码不同，将共享数据封装到一个对象中，将这个对象逐一传递给各个runnable对象
     * 3.如果多个线程执行的代码不同，将共享数据作为外部类的final成员变量，将不同的runnable对象作为内部类主动取数据
     */
    
    public static void main(String[] args) {
        //1.方式一
        Task1 task1 = new Task1();
        new Thread(task1).start();
        new Thread(task1).start();
        new Thread(task1).start();
        
        
        
    }
    

}

class Task1 implements Runnable{
    /**
     * 1.如果线程执行的代码相同，多个线程共享同一个runnable对象时，将共享数据放在runnable对象
     */
    
    private int i = 100;

    @Override
    public void run() {
        increase();
        decrease();
    }
    
    private synchronized void increase(){
        try {
            Thread.sleep(200);//为了更容易看到线程执行现象
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        i++;
        System.out.println(Thread.currentThread().getName() +",num:"+i);
    }
    private synchronized void decrease(){
        i--;
        System.out.println(Thread.currentThread().getName() +",num:"+i);
    }

运行结果：最终还是100，不同的线程使用共享数据

运行结果
//    Thread-0,num:101
//    Thread-2,num:102
//    Thread-1,num:103
//    Thread-2,num:102
//    Thread-0,num:101
//    Thread-1,num:100

2.如果多个线程执行的代码不同，将共享数据封装到一个对象中，将这个对象逐一传递给各个runnable对象

public class MuiltThreadDataShare2 {
    public static void main(String[] args) {
        // 2.如果多个线程执行的代码不同，将共享数据封装到一个对象中，将这个对象逐一传递给各个runnable对象
        /**
         * 模拟银行转账功能，可以指定存取款金额，账号初始额度100
         */
        ShareData data = new ShareData(0);

        // 存50元
        new Thread(new TaskIncrease(data, 50)).start();
        // 取30元
        new Thread(new Taskdecrease(data, 30)).start();
        // 存20
        new Thread(new TaskIncrease(data, 20)).start();

    }

}

class Taskdecrease implements Runnable {
    public Taskdecrease(ShareData shareData, int num) {
        this.shareData = shareData;
        this.num = num;
    }

    private int num;

    private ShareData shareData;

    @Override
    public void run() {
        shareData.decrease(num);
    }

}

class TaskIncrease implements Runnable {
    public TaskIncrease(ShareData shareData, int num) {
        this.shareData = shareData;
        this.num = num;
    }

    private ShareData shareData;
    private int num;

    @Override
    public void run() {
        shareData.increase(num);
    }

}

class ShareData {
    public ShareData(int num) {
        i = num;
        System.out.println("账户进行初始化,金额为：" + num);
    }

    private int i;

    public synchronized void increase(int i) {
        try {
            Thread.sleep(200);// 为了更容易看到线程执行现象
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.i = this.i + i;
        System.out.println(Thread.currentThread().getName() + "账户存入" + i + "元,目前账户余额为:" + this.i);
    }

    public synchronized void decrease(int i) {
        this.i = this.i - i;
        System.out.println(Thread.currentThread().getName() + "账户取出" + i + "元,目前账户余额为:" + this.i);
    }
}

运行结果：

账户进行初始化,金额为：0
Thread-0账户存入50元,目前账户余额为:50
Thread-2账户存入20元,目前账户余额为:70
Thread-1账户取出30元,目前账户余额为:40

3.如果多个线程执行的代码不同，将共享数据作为外部类的final成员变量，将不同的runnable对象作为内部类主动取数据

public class MuiltThreadDataShare3 {


    public static void main(String[] args) {
        final Data data = new Data();
        new Thread(new Runnable() {
            @Override
            public void run() {
                data.decrease(10);
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                data.increase(30);
            }
        }).start();

    }

}

class Data {
    private int money = 100;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public synchronized void increase(int i) {
        try {
            Thread.sleep(200);// 为了更容易看到线程执行现象
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.money = this.money + i;
        System.out.println(Thread.currentThread().getName() + "账户存入" + i + "元,目前账户余额为:" + this.money);
    }

    public synchronized void decrease(int i) {
        this.money = this.money - i;
        System.out.println(Thread.currentThread().getName() + "账户取出" + i + "元,目前账户余额为:" + this.money);
    }

}

4.将数据声明为static的方式

public class MuiltThreadDataShare4 {
    private static int num = 100;

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                increase(100);
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                decrease(30);
            }
        }).start();
    }

    public static synchronized void increase(int i) {
        try {
            Thread.sleep(200);// 为了更容易看到线程执行现象
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = num + i;
        System.out.println(Thread.currentThread().getName() + "账户存入" + i + "元,目前账户余额为:" + num);
    }

    public static synchronized void decrease(int i) {
        num = num - i;
        System.out.println(Thread.currentThread().getName() + "账户取出" + i + "元,目前账户余额为:" + num);
    }

}

完