多个线程之间共享数据

最新推荐文章于 2023-08-02 11:13:37 发布
最新推荐文章于 2023-08-02 11:13:37 发布
阅读量3k 收藏 5
点赞数 1

多个线程之间共享数据，首先想到的是将共享数据设置为全局变量，并且用static修饰，但是static修饰的变量是类变量，生命周期太长了，占用内存，本文将介绍三种方法实现多个线程之间共享数据。

方法一：多个线程对共享数据的操作是相同的，那么创建 
一个Runnable的子类对象，将这个对象作为参数传递给Thread的构造方法，此时因为多个线程操作的是同一个Runnable的子类对象，所以他们操作的是同一个共享数据。比如：买票系统，所以的线程的操作都是对票数减一的操作。 
代码如下：

public class MutilThreadShareDate{
    public static void main(String[] args) {
        oneRunnable();
    }

    //买票系统
    public static void oneRunnable(){
        ShareDate1 date1 = new ShareDate1();
        // 因为四个线程访问的是同一个date对象，所以数据之间可以共享
        new Thread(date1).start();
        new Thread(date1).start();
        new Thread(date1).start();
        new Thread(date1).start();
    }
}
class ShareDate1 implements Runnable {
    int j = 100;//共享变量
    public synchronized void decrement() {
    System.out.println(Thread.currentThread().getName() + ",做j--的操作," + j);
        j--;
    }

    @Override
    public void run() {
        /*
         * 怎么做到线程安全，保证，让票数大于0呢？
         * 因为票数j属于共享数据，当j满足条件时进去while循环，while循环中加了锁，保证线程安全
         * 当多个线程进入了while循环，在等待锁的时，别的线程对j进行了j--的操作，当j减到0时，等待的线程获得锁之后，还会继续做j--的操作，导致j为负数，所以要对j再次加一判断。
         */
        while (j > 0) {
            synchronized (this) {
                if (j > 0) {
                    //让当前线程停下10ms，让出cpu的执行权，其他线程不能获得锁，但是可以运行不需要该锁的代码。10s中到了，就自动向下执行
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    decrement();
                }
            }
        }
    }
}
  • 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

方法二：多个线程对共享数据的操作是不同的，将共享数据和操作共享数据的方法放在同一对象中，将这个对象作为参数传递给Runnable的子类，在子类中用该对象的方法对共享数据进行操作。如：生产者消费则。 
代码如下：

public class MutilThreadShareDate{
    public static void main(String[] args) {
        twoRunnable2();
    }
public static void twoRunnable2(){
        final ShareDate1 date1 = new ShareDate1();
        new Thread(new MyRunnable1(date1)).start();
        new Thread(new MyRunnable2(date1)).start();
    }
}


//创建两个Runnable的子类对象，对象接收一个参数，对这个参数进行操作，实现数据间的共享
class MyRunnable1 implements Runnable{
    private ShareDate1 date1;
    public MyRunnable1(ShareDate1 date1){
        this.date1 = date1;
    }
    @Override
    public void run() {
        while(date1.j > 100){
            date1.decrement();
        }

    }
}
//创建两个Runnable的子类对象，对象接收一个参数，对这个参数进行操作，实现数据间的共享
class MyRunnable2 implements Runnable{
    private ShareDate1 date1;
    public MyRunnable2(ShareDate1 date1){
        this.date1 = date1;
    }
    @Override
    public void run() {
        while(date1.j < 200){
            date1.increment();
        }

    }
}
//共享数据所在的类
class ShareDate1 implements Runnable {
    int j = 100;

    public synchronized void increment() {
        System.out.println(Thread.currentThread().getName() + ",做j++的操作," + j);
        j++;
    }

    public synchronized void decrement() {
        System.out.println(Thread.currentThread().getName() + ",做j--的操作," + j);
        j--;
    }

    @Override
    public void run() {
        /*
         * 怎么做到线程安全，保证，票数大于0呢？
         * 因为票数j属于共享数据，当j满足条件时进去while循环，while循环中加了锁，保证线程安全
         * 当多个线程进入了while循环，在等待锁的时，别的线程对j进行了j--的操作，当j减到0时，等待的线程获得锁之后，还会继续做j--的操作，导致j为负数，所以要对j再次加一判断。
         */
        while (j > 0) {
            synchronized (this) {
                if (j > 0) {
                    //让当前线程停下10ms，让出cpu的执行权，其他线程不能获得锁，但是可以运行不需要锁的代码。
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    decrement();
                }
            }
        }

    }
}
  • 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
  • 78

方法三：多个线程对共享数据的操作是不同的， 用内部类的方式去实现，创建Runnable的子类作为内部类，将共享对象作为全局变量，在Runnable的子类中对共享数据进行操作。 
代码如下：

public class MutilThreadShareDate{
    public static void main(String[] args) {
        twoRunnable1();
    }
public static void twoRunnable1(){
        //内部类调用外部类的对象，外部类的对象必须用final修饰，保证内部类不能修改他。
        final ShareDate1 date1 = new ShareDate1();
        /*
         * 因为这两个线程操作的是同一个对象，所以用的是同一个j，这个j在两个线程中间是共享的。
         */
        new Thread(
            new Runnable(){
                @Override
                public void run() {
                    date1.increment();
                }
            }
        ).start();

        new Thread(
                new Runnable(){
                    @Override
                    public void run() {
                        date1.decrement();
                    }
                }
            ).start();
    }
}

//共享数据所在的类
class ShareDate1 implements Runnable {
    int j = 100;

    public synchronized void increment() {
        System.out.println(Thread.currentThread().getName() + ",做j++的操作," + j);
        j++;
    }

    public synchronized void decrement() {
        System.out.println(Thread.currentThread().getName() + ",做j--的操作," + j);
        j--;
    }

    @Override
    public void run() {
        /*
         * 怎么做到线程安全，保证，票数大于0呢？
         * 因为票数j属于共享数据，当j满足条件时进去while循环，while循环中加了锁，保证线程安全
         * 当多个线程进入了while循环，在等待锁的时，别的线程对j进行了j--的操作，当j减到0时，等待的线程获得锁之后，还会继续做j--的操作，导致j为负数，所以要对j再次加一判断。
         */
        while (j > 0) {
            synchronized (this) {
                if (j > 0) {
                    //让当前线程停下10ms，让出cpu的执行权，其他线程不能获得锁，但是可以运行不需要锁的代码。
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    decrement();
                }
            }
        }

    }
}
sinat_36475966
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
如何在两个线程间共享数据
小小鱼儿小小林的博客
03-19 66
在Java中，可以通过共享对象的方式在两个线程之间共享数据。具体来说，可以将共享的数据封装在一个对象中，然后让多个线程访问该对象
C++多线程编程时的数据保护
12-26
在编写多线程程序时，多个线程同时访问某个共享资源，会导致同步的问题，这篇文章中我们将介绍 C++11 多线程编程中的数据保护。 数据丢失 让我们从一个简单的例子开始，请看如下代码：   #include <iostream> #include <string> #include <thread> #include <vector> using std::thread; using std::vector; using std::cout; using std::endl; class Incrementer { private: int counter; public:
多线程：多个线程共享数据
少年啦飞啦的博客
12-08 779
在 Java 传统线程机制中的共享数据方式，大致可以简单分两种情况： 多个线程行为一致，共同操作一个数据源。也就是每个线程执行的代码相同，可以使用同一个 Runnable 对象，这个 Runnable 对象中有那个共享数据，例如，卖票系统就可以这么做。 多个线程行为不一致，共同操作一个数据源。也就是每个线程执行的代码不同，这时候需要用不同的Runnable 对象。例如，银行存取款。 1、同样的...
Java多线程共享数据、同步、通信
12-22
一、线程共享数据 　　a)继承Thread，那么我们可以创建很多个这样的类，但是每个这样的类都是相互不关联的，也是说我们Thread类中的内容每个创建出来的类都有一份，因此它不适合作为数据共享的线程来操作。同时由于Java继承的性，我们只能继承一个对象。 　　b)使用runnable可以解决性和不能共享的问题（不是说使用runnable解决了共享问题，只是相对于创建Thread来说，它可以算的上是共享了，为了获得更精确的共享问题，它必须的使用线程同步操作）。实现了runnable接口的类比较适合用作共享数据。 　　一个测试例子à证明runnable能实现数据共享，thread不能
Java多线程编程之访问共享对象和数据的方法
09-03
主要介绍了Java多线程编程之访问共享对象和数据的方法,多个线程访问共享对象和数据的方式有两种情况,本文分别给出代码实例,需要的朋友可以参考下
qt线程共享数据 信号和槽方式
03-15
使用共享内存。即使用一个两个线程都能够共享的变量（如全局变量），这样两个线程都能够访问和修改该变量，从而达到共享数据的目的。 Qt 线程间共享数据是本文介绍的内容，多的不说，先来啃内容。Qt线程间共享数据主要有两种方式： 使用共享内存。即使用一个两个线程都能够共享的变量（如全局变量），这样两个线程都能够访问和修改该变量，从而达到共享数据的目的； 使用singal/slot机制，把数据从一个线程传递到另外一个线程。 第一种办法在各个编程语言都使用普遍，而第二种方式倒是QT的特有方式，下面主要学习一下这种方式
多个线程访问共享对象和数据的方式
weixin_33701294的博客
05-10 212
多个线程访问共享对象和数据的方式有两种情况：1、每个线程执行的代码相同，例如，卖票：多个窗口同时卖这100张票，这100张票需要多个线程共享。2、每个线程执行的代码不同，例如：设计四个线程，其中两个线程每次对j增加1，另外两个线程每次对j减少1。 a、如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个对象中有共享数据。卖票就可以这样做，每个窗口都在做卖票任务，卖的票都是同一个数...
c++多线程（二）线程间共享数据
deroy
06-29 908
线程间共享数据，锁的应用
多进程和多线程数据共享
最新发布
www_z_dd的博客
08-02 1544
多线程之间的数据共享是通过线程共享同一个进程的内存空间来实现的，因此多个线程可以直接访问相同的内存地址，从而实现数据的共享。这使得多线程编程更加方便，因为不需要像多进程那样使用额外的机制进行进程间通信。然而，多线程共享数据也带来了潜在的问题，比如数据竞争和并发访问问题。当多个线程同时访问共享的数据时，可能会导致数据的不一致性或损坏。因此，在进行多线程编程时，需要合理地处理数据共享，避免数据竞争。
如何在两个线程之间共享数据
2301_78008478的博客
05-17 673
的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间 一些公共变量的传递的复杂度。将数据抽象成一个类，并将对这个数据的操作作为这个类的方法，这么设计可以和容易做到同步，操作方法也封装在外部类，以便实现对数据的各个操作的同步和互斥，作为内部类的各个。对象作为一个类的内部类，共享数据作为这个类的成员变量，每个线程对共享数据的。）解决了可见性和有序性的问题，而锁解决了原子性的问题，理想情。将数据抽象成一个类，并将数据的操作作为这个类的方法。对象作为一个类的内部类。
Closely interleaved self-comparison method applied to precise measurement
02-07
A self-comparison method with closely interleaved switching states is analyzed and used to evaluate some type-B uncertainties of an 87Rb atomic fountain clock. Free from additional frequency reference, the method can be applied to a running fountain to reach a precision beyond its uncertainty. A verification experiment proves an uncertainty of 9.2×10-16 at an averaging time of 242500 s. Further, the method is applied to measure light shift, and no visible relative frequency shift is found in the
多个线程之间共享数据的方式
04-19
NULL 博文链接：https://903497571.iteye.com/blog/1869428
Comparison method violates its general contract 出现原因和解决方法
牧码人的博客
05-10 820
FastJSON 1.2.62版本使用JSON.toJSONString()报错 Comparison method violates its general contract! 解决方案：换成fastjson 1.2.67版本 解决
Java线程池关键参数及线程池类型选择
qq_31439011的博客
09-14 5855
一次读懂Java线程池关键参数及线程池类型选择 一、java线程池关键参数 针对java语言，通过线程池源码来分析线程池，线程池源码，可以看到，线程池主要包括以下几个参数： 源码中对每个参数的解释如下： 针对每一个参数，意思就是说： （1）corePoolSize：核心线程数，该参数说明了在线程池中保持核心线程的数量，由自己定义，刚创建线程池时，里面的核心线程数为0，随着任务的添...
多线程如何共享变量 -- Java内存模型
大雄送你走的博客
03-20 2518
目录 主内存和工作内存 为什么要分为主内存和工作内存 Java 内存模型和运行时数据区的区别 Java 内存模型中变量的定义 内存之间交互操作 参考 主内存和工作内存 Java 内存模型（JMM：Java Memory Model）规定了所有的变量都存储在主内存中。 每条线程还有自己的工作内存，工作内存中保存了该线程使用到的变量到主内存副本拷贝。 线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存中的变量。 不同线程之间无法直接访问对方工作内存中的变量，线程间变量值的传递均需要在主内存来
线程池创建及参数设置
weixin_41992498的博客
12-03 1115
一、创建线程池以及线程池的各种参数分析： //不指定最大线程数，默认是Int的最大值 ExecutorService executorService = Executors.newCachedThreadPool(); executorService.submit(() -> { System.out.println("新建线程池对象，执行第一个默认线程"); }); executorService.shutdown(); //指定最大
线程间的数据共享与参数传递
08-09 1267
线程间的数据共享 ：文件共享、全局变量、堆区数据均共享。但是栈区不共享。 线程之间的参数传递及代码说明
Java中多线程之间如何实现数据共享
07-28
Java中多线程之间可以通过以下方式实现数据共享： 1. 使用共享变量：可以定义一个共享变量，在多个线程中通过读取和修改该变量来实现数据共享。需要注意的是，如果多个线程同时修改共享变量，可能会导致数据不一致的问题，因此需要使用同步机制（如synchronized关键字）来保证线程安全。 2. 使用线程安全的集合类：Java提供了一些线程安全的集合类，如ConcurrentHashMap、ConcurrentLinkedQueue等，可以在多个线程中安全地进行读写操作，从而实现数据共享。 3. 使用volatile关键字：使用volatile关键字修饰共享变量，可以确保多个线程对该变量的操作都是可见的。即一个线程对共享变量的修改对其他线程是可见的，避免了数据不一致的问题。 4. 使用锁机制：可以使用锁机制（如ReentrantLock）来保证在同一时间只有一个线程可以访问共享数据，其他线程需要等待锁释放后才能继续执行。这样可以保证数据的一致性和线程安全性。 需要根据具体情况选择适合的方式来实现数据共享，并且要注意线程安全性和数据一致性的问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值