原文地址：http://blog.csdn.net/hejingyuan6/article/details/47053409#

多线程共享数据的方式：

1，如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，卖票系统就可以这么做。

2，如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，例如，设计4个线程。其中两个线程每次对j增加1，另外两个线程对j每次减1，银行存取款

 

有两种方法来解决此类问题：

将共享数据封装成另外一个对象，然后将这个对象逐一传递给各个Runnable对象，每个线程对共享数据的操作方法也分配到那个对象身上完成，这样容易实现针对数据进行各个操作的互斥和通信

将Runnable对象作为一个类的内部类，共享数据作为这个类的成员变量，每个线程对共享数据的操作方法也封装在外部类，以便实现对数据的各个操作的同步和互斥，作为内部类的各个Runnable对象调用外部类的这些方法。

每个线程执行的代码相同，可以使用同一个Runnable对象

卖票系统demo：

package com.xujishou;

public class SellTicket {

    /**

     * @param args

     */

    public static void main(String[] args) {

        Ticket t = new Ticket();

        new Thread(t).start();

        new Thread(t).start();

    }

}

class Ticket implements Runnable {

    private int ticket = 10;

    public void run() {

        while (ticket > 0) {

            ticket--;

            System.out.println("当前票数为：" + ticket);

        }

    }

}

执行

简单的多线程间数据共享，每个线程执行的代码不同，用不同的Runnable对象

设计4个线程。

其中两个线程每次对j增加1，另外两个线程对j每次减1

package com.xujishou;

public class TestThread {

    /**

     * @param args

     */

    public static void main(String[] args) {

        final MyData data = new MyData();

        for (int i = 0; i < 10; i++) {

            new Thread(new Runnable() {

                public void run() {

                    data.add();

                }

            }).start();

            new Thread(new Runnable() {

                public void run() {

                    data.dec();

                }

            }).start();

        }

    }

}

class MyData {

    private int j = 0;

    public synchronized void add() {

        j++;

        System.out.println("线程" + Thread.currentThread().getName() + "j为：" + j);

    }

    public synchronized void dec() {

        j--;

        System.out.println("线程" + Thread.currentThread().getName() + "j为：" + j);

    }

}

银行存取款实例：

package com.xujishou;

public class Acount {

    private int money;

    public Acount(int money) {

        this.money = money;

    }

    public synchronized void getMoney(int money) {

        // 注意这个地方必须用while循环，因为即便再存入钱也有可能比取的要少

        while (this.money < money) {

            System.out.println("取款：" + money + " 余额：" + this.money

                    + " 余额不足，正在等待存款......");

            try {

                wait();

            } catch (Exception e) {

            }

        }

        this.money = this.money - money;

        System.out.println("取出：" + money + " 还剩余：" + this.money);

    }

    public synchronized void setMoney(int money) {

        try {

            Thread.sleep(10);

        } catch (Exception e) {

        }

        this.money = this.money + money;

        System.out.println("新存入：" + money + " 共计：" + this.money);

        notify();

    }

    public static void main(String args[]) {

        Acount Acount = new Acount(0);

        Bank b = new Bank(Acount);

        Consumer c = new Consumer(Acount);

        new Thread(b).start();

        new Thread(c).start();

    }

}

// 存款类

class Bank implements Runnable {

    Acount Acount;

    public Bank(Acount Acount) {

        this.Acount = Acount;

    }

    public void run() {

        while (true) {

            int temp = (int) (Math.random() * 1000);

            Acount.setMoney(temp);

        }

    }

}

// 取款类

class Consumer implements Runnable {

    Acount Acount;

    public Consumer(Acount Acount) {

        this.Acount = Acount;

    }

    public void run() {

        while (true) {

            int temp = (int) (Math.random() * 1000);

            Acount.getMoney(temp);

        }

    }

}

　　

总结：

其实多线程间的共享数据最主要的还是互斥，多个线程共享一个变量，针对变量的操作实现原子性即可。

原文地址：http://blog.csdn.net/hejingyuan6/article/details/47053409#

多线程共享数据的方式：

1，如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，卖票系统就可以这么做。

2，如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，例如，设计4个线程。其中两个线程每次对j增加1，另外两个线程对j每次减1，银行存取款

 

有两种方法来解决此类问题：

将共享数据封装成另外一个对象，然后将这个对象逐一传递给各个Runnable对象，每个线程对共享数据的操作方法也分配到那个对象身上完成，这样容易实现针对数据进行各个操作的互斥和通信

将Runnable对象作为一个类的内部类，共享数据作为这个类的成员变量，每个线程对共享数据的操作方法也封装在外部类，以便实现对数据的各个操作的同步和互斥，作为内部类的各个Runnable对象调用外部类的这些方法。

下面逐一介绍

每个线程执行的代码相同，可以使用同一个Runnable对象

卖票系统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
package com.xujishou;
 
public class SellTicket {
    /**
     * @param args
     */
    public static void main(String[] args) {
        Ticket t = new Ticket();
        new Thread(t).start();
        new Thread(t).start();
    }
}
 
class Ticket implements Runnable {
 
    private int ticket = 10;
 
    public void run() {
        while (ticket > 0) {
            ticket--;
            System.out.println("当前票数为：" + ticket);
        }
 
    }
}

执行

简单的多线程间数据共享，每个线程执行的代码不同，用不同的Runnable对象

设计4个线程。

其中两个线程每次对j增加1，另外两个线程对j每次减1

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
41
42
43
44
package com.xujishou;
 
public class TestThread {
    /**
     * @param args
     */
    public static void main(String[] args) {
        final MyData data = new MyData();
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
 
                public void run() {
                    data.add();
 
                }
 
            }).start();
            new Thread(new Runnable() {
 
                public void run() {
                    data.dec();
 
                }
 
            }).start();
        }
    }
 
}
 
class MyData {
    private int j = 0;
 
    public synchronized void add() {
        j++;
        System.out.println("线程" + Thread.currentThread().getName() + "j为：" + j);
    }
 
    public synchronized void dec() {
        j--;
        System.out.println("线程" + Thread.currentThread().getName() + "j为：" + j);
    }
 
}

银行存取款实例：

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
package com.xujishou;
 
public class Acount {
 
    private int money;
 
    public Acount(int money) {
        this.money = money;
    }
 
    public synchronized void getMoney(int money) {
        // 注意这个地方必须用while循环，因为即便再存入钱也有可能比取的要少
        while (this.money < money) {
            System.out.println("取款：" + money + " 余额：" + this.money
                    + " 余额不足，正在等待存款......");
            try {
                wait();
            } catch (Exception e) {
            }
        }
        this.money = this.money - money;
        System.out.println("取出：" + money + " 还剩余：" + this.money);
 
    }
 
    public synchronized void setMoney(int money) {
 
        try {
            Thread.sleep(10);
        } catch (Exception e) {
        }
        this.money = this.money + money;
        System.out.println("新存入：" + money + " 共计：" + this.money);
        notify();
    }
 
    public static void main(String args[]) {
        Acount Acount = new Acount(0);
        Bank b = new Bank(Acount);
        Consumer c = new Consumer(Acount);
        new Thread(b).start();
        new Thread(c).start();
    }
}
 
// 存款类
class Bank implements Runnable {
    Acount Acount;
 
    public Bank(Acount Acount) {
        this.Acount = Acount;
    }
 
    public void run() {
        while (true) {
            int temp = (int) (Math.random() * 1000);
            Acount.setMoney(temp);
        }
    }
 
}
 
// 取款类
class Consumer implements Runnable {
    Acount Acount;
 
    public Consumer(Acount Acount) {
        this.Acount = Acount;
    }
 
    public void run() {
        while (true) {
            int temp = (int) (Math.random() * 1000);
            Acount.getMoney(temp);
        }
    }
}

　　

总结：

其实多线程间的共享数据最主要的还是互斥，多个线程共享一个变量，针对变量的操作实现原子性即可。

JAVA 并发编程-多个线程之间共享数据的更多相关文章

  1. JAVA 并发编程-多个线程之间共享数据（六）

    多线程共享数据的方式: 1.假设每一个线程运行的代码同样.能够使用同一个Runnable对象,这个Runnable对象中有那个共享数据,比如,卖票系统就能够这么做. 2,假设每一个线程运行的代码不同. ...

  2. 【转】JAVA 并发编程-多个线程之间共享数据

    原文地址:http://blog.csdn.net/hejingyuan6/article/details/47053409# 多线程共享数据的方式: 1,如果每个线程执行的代码相同,可以使用同一个R ...

  3. Java并发编程--6.Exchanger线程间交换数据

    在两个线程之间定义同步点,当两个线程都到达同步点时,他们交换数据结构,因此第一个线程的数据结构进入到第二个线程中,第二个线程的数据结构进入到第一个线程中 在生产者-消费者情境模式中它包含了一个数缓冲区 ...

  4. Java并发编程系列-(2) 线程的并发工具类

    2.线程的并发工具类 2.1 Fork-Join JDK 7中引入了fork-join框架,专门来解决计算密集型的任务.可以将一个大任务,拆分成若干个小任务,如下图所示: Fork-Join框架利用了 ...

  5. 【Java并发编程一】线程安全和共享对象

    一.什么是线程安全 当多个线程访问一个类时,如果不用考虑这些线程在运行时环境下的调度和交替执行,并且不需要额外的同步及在调用代码代码不必作其他的协调,这个类的行为仍然是正确的,那么称这个类是线程安全的 ...

  6. Java并发编程实战 之 对象的共享

    上一篇介绍了如何通过同步多个线程避免同一时刻访问相同数据,本篇介绍如何共享和发布对象,使它们被安全地由多个进程访问. 1.可见性 通常,我们无法保证执行读操作的线程能看到其他线程写入的值,因为每个线程 ...

  7. 【java并发编程实战】-----线程基本概念

    学习Java并发已经有一个多月了,感觉有些东西学习一会儿了就会忘记,做了一些笔记但是不系统,对于Java并发这么大的"系统",需要自己好好总结.整理才能征服它.希望同仁们一起来学习 ...

  8. Java并发编程扩展（线程通信、线程池）

    之前我说过,实现多线程的方式有4种,但是之前的文章中,我只介绍了两种,那么下面这两种,可以了解了解,不懂没关系. 之前的文章-->Java并发编程之多线程 使用ExecutorService.C ...

  9. Java并发编程:进程和线程的由来(转)

    Java多线程基础:进程和线程之由来 在前面,已经介绍了Java的基础知识,现在我们来讨论一点稍微难一点的问题:Java并发编程.当然,Java并发编程涉及到很多方面的内容,不是一朝一夕就能够融会贯通 ...

随机推荐

  1. Spring Boot后台启动不打印nohup.out

    #!/bin/bashnohup java -jar websocket-server-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod --serve ...

  2. 转 -- OK6410 tftp下载内核、文件系统以及nand flash地址相关整理、总结

    转载地址:http://emouse.cnblogs.com/ 飞凌官方提供了一键下载烧写linux的方式,相对来说比较方便,但是对于开发来说不够灵活,因此这篇文章把tftp相关的点介绍一下,整理下其 ...

  3. 微服务深入浅出（8）-- 配置中心Spring Cloud Config

    Config Server从本地读取配置文件 将所有的配置文件统一写带Config Server过程的目录下,Config Server暴露Http API接口,Config Client调用Conf ...

  4. 【leetcode 简单】 第一百一十题 分发饼干

    假设你是一位很棒的家长,想要给你的孩子们一些小饼干.但是,每个孩子最多只能给一块饼干.对每个孩子 i ,都有一个胃口值 gi ,这是能让孩子们满足胃口的饼干的最小尺寸:并且每块饼干 j ,都有一个尺寸 ...

  5. PL/SQ连接oracle，L 新建表的时候， virtual那一列是什么意思

    Virtual标示该栏位是否为虚拟列. https://www.2cto.com/database/201306/216917.html

  6. [Ubuntu 14.04] 创建可以用于Android的WIFI热点

    Ubuntu的网络管理为创建Wifi热点提供了方便,可是因为它用了ad-hoc网络,所以其创建的Wifi又不能让Android系统使用.这篇文字就是为了解决这个问题 1.Install AP-Host ...

  7. 【codeforces】【比赛题解】#872 CF Round #440 (Div.2)

    链接. [A]寻找漂亮数字 题意: 给定了两列非零数字.我们说一个数是漂亮的,当它的十进制表达中有至少一个数从数列一中取出,至少有一个数从数列二中取出.最小的漂亮数字是多少? 输入: 第一行两个数\( ...

  8. python目前安装的包备份

    Package Version ------------------------------- ------------------ alembic altgraph 0.14 apistar app ...

  9. 串口流控制详解（CTS/RTS,DTR/DSR）

    1 首先看下关于流控相关的几个端口的解释如下图 除了必要的地(GND)要连接外,其它连如下 步骤阅读 2 计算机和猫(MODEM)的连接 步骤阅读 步骤阅读 3 计算机和非猫的连接(null  mod ...

  10. MySQL异步复制、半同步复制详解

    MySQL数据复制的原理图大致如下: 从上图我们可以看出MySQL数据库的复制需要启动三个线程来实现: 其中1个在主服务器上,另两个在从服务器上.当发出START SLAVE时,从服务器创建一个I/O ...