精华内容
下载资源
问答
  • Java线程间通信的方式线程间的通信方式①同步这里讲的同步是指多个线程通过 synchronized 关键字这种方式来实现线程间的通信。参考示例:[](javascript:void(0)????public class MyObject {synchronized public void...

    Java线程间通信的方式

    线程间的通信方式

    ①同步

    这里讲的同步是指多个线程通过 synchronized 关键字这种方式来实现线程间的通信。

    参考示例:

    [

    48304ba5e6f9fe08f3fa1abda7d326ab.png](javascript:void(0)😉

    public class MyObject {

    synchronized public void methodA() {

    //do something....

    }

    synchronized public void methodB() {

    //do some other thing

    }

    }

    public class ThreadA extends Thread {

    private MyObject object;

    //省略构造方法

    @Override

    public void run() {

    super.run();

    object.methodA();

    }

    }

    public class ThreadB extends Thread {

    private MyObject object;

    //省略构造方法

    @Override

    public void run() {

    super.run();

    object.methodB();

    }

    }

    public class Run {

    public static void main(String[] args) {

    MyObject object = new MyObject();

    //线程A与线程B 持有的是同一个对象:object

    ThreadA a = new ThreadA(object);

    ThreadB b = new ThreadB(object);

    a.start();

    b.start();

    }

    }

    [

    48304ba5e6f9fe08f3fa1abda7d326ab.png](javascript:void(0)😉

    由于线程 A 和线程 B 持有同一个 MyObject 类的对象 object,尽管这两个线程需要调用不同的方法,但是它们是同步执行的,比如:线程 B 需要等待线程 A 执行完了 methodA() 方法之后,它才能执行 methodB() 方法。这样,线程 A 和线程 B 就实现了 通信。

    这种方式,本质上就是 “共享内存” 式的通信。多个线程需要访问同一个共享变量,谁拿到了锁(获得了访问权限),谁就可以执行。

    ②while 轮询的方式

    代码如下:

    [

    48304ba5e6f9fe08f3fa1abda7d326ab.png](javascript:void(0)😉

    1 import java.util.ArrayList;

    2 import java.util.List;

    4 public class MyList {

    6 private List list = new ArrayList();

    7 public void add() {

    8 list.add("elements");

    9 }

    10 public int size() {

    11 return list.size();

    12 }

    13 }

    15 import mylist.MyList;

    17 public class ThreadA extends Thread {

    19 private MyList list;

    21 public ThreadA(MyList list) {

    22 super();

    23 this.list = list;

    24 }

    26 @Override

    27 public void run() {

    28 try {

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

    30 list.add();

    31 System.out.println("添加了" + (i + 1) + "个元素");

    32 Thread.sleep(1000);

    33 }

    34 } catch (InterruptedException e) {

    35 e.printStackTrace();

    36 }

    37 }

    38 }

    40 import mylist.MyList;

    42 public class ThreadB extends Thread {

    44 private MyList list;

    46 public ThreadB(MyList list) {

    47 super();

    48 this.list = list;

    49 }

    51 @Override

    52 public void run() {

    53 try {

    54 while (true) {

    55 if (list.size() == 5) {

    56 System.out.println("==5, 线程b准备退出了");

    57 throw new InterruptedException();

    58 }

    59 }

    60 } catch (InterruptedException e) {

    61 e.printStackTrace();

    62 }

    63 }

    64 }

    66 import mylist.MyList;

    67 import extthread.ThreadA;

    68 import extthread.ThreadB;

    70 public class Test {

    72 public static void main(String[] args) {

    73 MyList service = new MyList();

    75 ThreadA a = new ThreadA(service);

    76 a.setName("A");

    77 a.start();

    79 ThreadB b = new ThreadB(service);

    80 b.setName("B");

    81 b.start();

    82 }

    83 }

    [

    48304ba5e6f9fe08f3fa1abda7d326ab.png](javascript:void(0)😉

    在这种方式下,线程 A 不断地改变条件,线程 ThreadB 不停地通过 while 语句检测这个条件 (list.size()==5) 是否成立 ,从而实现了线程间的通信。但是这种方式会浪费 CPU 资源。之所以说它浪费资源,是因为 JVM 调度器将 CPU 交给线程 B 执行时,它没做啥 “有用” 的工作,只是在不断地测试 某个条件是否成立。就类似于现实生活中,某个人一直看着手机屏幕是否有电话来了,而不是: 在干别的事情,当有电话来时,响铃通知 TA 电话来了。关于线程的轮询的影响,可参考:JAVA 多线程之当一个线程在执行死循环时会影响另外一个线程吗?

    这种方式还存在另外一个问题:

    轮询的条件的可见性问题,关于内存可见性问题,可参考:JAVA 多线程之 volatile 与 synchronized 的比较中的第一点 “一,volatile 关键字的可见性”

    线程都是先把变量读取到本地线程栈空间,然后再去再去修改的本地变量。因此,如果线程 B 每次都在取本地的 条件变量,那么尽管另外一个线程已经改变了轮询的条件,它也察觉不到,这样也会造成死循环。

    ③wait/notify 机制

    代码如下:

    [

    48304ba5e6f9fe08f3fa1abda7d326ab.png](javascript:void(0)😉

    1 import java.util.ArrayList;

    2 import java.util.List;

    4 public class MyList {

    6 private static List list = new ArrayList();

    8 public static void add() {

    9 list.add("anyString");

    10 }

    12 public static int size() {

    13 return list.size();

    14 }

    15 }

    18 public class ThreadA extends Thread {

    20 private Object lock;

    22 public ThreadA(Object lock) {

    23 super();

    24 this.lock = lock;

    25 }

    27 @Override

    28 public void run() {

    29 try {

    30 synchronized (lock) {

    31 if (MyList.size() != 5) {

    32 System.out.println("wait begin "

    33 + System.currentTimeMillis());

    34 lock.wait();

    35 System.out.println("wait end "

    36 + System.currentTimeMillis());

    37 }

    38 }

    39 } catch (InterruptedException e) {

    40 e.printStackTrace();

    41 }

    42 }

    43 }

    46 public class ThreadB extends Thread {

    47 private Object lock;

    49 public ThreadB(Object lock) {

    50 super();

    51 this.lock = lock;

    52 }

    54 @Override

    55 public void run() {

    56 try {

    57 synchronized (lock) {

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

    59 MyList.add();

    60 if (MyList.size() == 5) {

    61 lock.notify();

    62 System.out.println("已经发出了通知");

    63 }

    64 System.out.println("添加了" + (i + 1) + "个元素!");

    65 Thread.sleep(1000);

    66 }

    67 }

    68 } catch (InterruptedException e) {

    69 e.printStackTrace();

    70 }

    71 }

    72 }

    74 public class Run {

    76 public static void main(String[] args) {

    78 try {

    79 Object lock = new Object();

    81 ThreadA a = new ThreadA(lock);

    82 a.start();

    84 Thread.sleep(50);

    86 ThreadB b = new ThreadB(lock);

    87 b.start();

    88 } catch (InterruptedException e) {

    89 e.printStackTrace();

    90 }

    91 }

    92 }

    [

    48304ba5e6f9fe08f3fa1abda7d326ab.png](javascript:void(0)😉

    线程 A 要等待某个条件满足时 (list.size()==5),才执行操作。线程 B 则向 list 中添加元素,改变 list 的 size。

    A,B 之间如何通信的呢?也就是说,线程 A 如何知道 list.size() 已经为 5 了呢?

    这里用到了 Object 类的 wait() 和 notify() 方法。

    当条件未满足时 (list.size() !=5),线程 A 调用 wait() 放弃 CPU,并进入阻塞状态。--- 不像②while 轮询那样占用 CPU

    当条件满足时,线程 B 调用 notify() 通知 线程 A,所谓通知线程 A,就是唤醒线程 A,并让它进入可运行状态。

    这种方式的一个好处就是 CPU 的利用率提高了。

    但是也有一些缺点:比如,线程 B 先执行,一下子添加了 5 个元素并调用了 notify() 发送了通知,而此时线程 A 还执行;当线程 A 执行并调用 wait() 时,那它永远就不可能被唤醒了。因为,线程 B 已经发了通知了,以后不再发通知了。这说明:通知过早,会打乱程序的执行逻辑。

    ④管道通信就是使用 java.io.PipedInputStream 和 java.io.PipedOutputStream 进行通信具体就不介绍了。

    分布式系统中说的两种通信机制:共享内存机制和消息通信机制。感觉前面的①中的 synchronized 关键字和②中的 while 轮询 “属于” 共享内存机制,由于是轮询的条件使用了 volatile 关键字修饰时,这就表示它们通过判断这个 “共享的条件变量 “是否改变了,来实现进程间的交流。

    而管道通信,更像消息传递机制,也就是说:通过管道,将一个线程中的消息发送给另一个。

    关于 wait/notify 更多内容,可参考:JAVA 多线程之 wait/notify

    展开全文
  • 线程同步

    2017-09-21 21:57:41
    什么是线程同步线程同步的真实意思和字面意思恰好相反。 线程同步的真实意思,其实“排队”:几个线程之间要排队,一个一个对共享资源进行操作,而不是同时进行操作。为什么线程同步线程有可能和其他线程共享一些...

    什么是线程同步

    线程同步的真实意思和字面意思恰好相反。
    线程同步的真实意思,其实是“排队”:几个线程之间要排队,一个一个对共享资源进行操作,而不是同时进行操作。

    为什么线程同步

    线程有可能和其他线程共享一些资源,比如,内存,文件,数据库等。
    当多个线程同时读写同一份共享资源的时候,可能会引起冲突。这时候,我们需要引入线程“同步”机制,即各位线程之间要有个先来后到,不能一窝蜂挤上去抢作一团。

    怎么线程同步

    进程中线程同步的四种常用方式

    1. 临界区(CCriticalSection)

    多个线程访问一个独占性共享资源时,可以使用临界区对象
    拥有临界区的线程可以访问被保护起来的资源或代码段

    2、 事件(CEvent)

    允许一个线程在处理完一个任务后,主动唤醒另外一个线程执行任务
    防止他人进入的简单方法,就是门口加一把锁。先到的人锁上门,后到的人看到上锁,就在门口排队,等锁打开再进去

    3. “互斥锁”

    防止多个线程同时读写某一块内存区域

    还有些房间,可以同时容纳n个人,比如厨房

    某些内存区域,只能供给固定数目的线程使用

    就是在门口挂n把钥匙。进去的人就取一把钥匙,出来时再把钥匙挂回原处。后到的人发现钥匙架空了,就知道必须在门口排队等着了。

    4. 信号量”

    用来保证多个线程不会互相冲突

    1)wait():使一个线程处于等待状态,并且释放所持有的对象的lock。
    (2)sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要捕捉
    notify():唤醒一个处于等待状态的线程,注意的是在调用此方法的时候,并不能确切的
    唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且不是按优先级
    (4)notityAll ():唤醒所有处入等待状态的线程,注意并不是给所有唤醒线程一个对象的锁,
    而是让它们竞争
    https://zhidao.baidu.com/question/327685723.html

    展开全文
  • 线程安全的本质体现在两个方面,A变量安全:多线程同时运行一段代码B线程同步:一个线程还没执行完,另一个线程又进来接着执行。看个简单的例子。Java代码public class ThreadSafe implements java。lang。...

    线程安全的本质体现在两个方面,

    A变量安全:多线程同时运行一段代码

    B线程同步:一个线程还没执行完,另一个线程又进来接着执行。

    看个简单的例子。

    Java代码

    public class ThreadSafe implements java。

    lang。Runnable {

    int num = 1;

    public void run() {

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

    num = num + 1;

    try {

    Thread。sleep(2000);

    } catch (InterruptedException e) {

    e。

    printStackTrace();

    }

    System。out。println("num is value +==="+Thread。currentThread()。getName()+"---------" + num);

    }

    }

    }

    TestMan。

    java 写道

    package com。java。thread。test;

    public class TestMan {

    public static void main(String[] args) {

    Runnable safe=new ThreadSafe();

    Thread thread1=new Thread(safe,"thread1");

    Thread thread2=new Thread(safe,"thread2");

    thread1。

    start();

    thread2。start();

    }

    }

    运行结果

    num is value +===thread2---------3

    num is value +===thread1---------4

    num is value +===thread2---------5

    num is value +===thread1---------6

    num is value +===thread1---------7

    num is value +===thread2---------7

    很明显是错误的,应为两个线程共享同一个变量。

    这里就是变量的安全问题。

    解决办法:

    1抛弃单实例,多线程的方式,用多实例,多线程的方式,这样就和单线程是一个样了,不会出错,但是是最接近传统的编程模式

    2不要用类的实例变量,经可能把变量封装到方法内部。

    1类的解决办法的代码。

    Java代码

    public class TestMan {

    public static void main(String[] args) {

    Runnable safe=new ThreadSafe();

    Runnable safe2=new ThreadSafe();

    Thread thread1=new Thread(safe,"thread1");

    Thread thread2=new Thread(safe2,"thread2");

    thread1。

    start();

    thread2。

    start();

    }

    }

    运行结果

    num is value +===thread1---------2

    num is value +===thread2---------2

    num is value +===thread1---------3

    num is value +===thread2---------3

    num is value +===thread1---------4

    num is value +===thread2---------4。

    全部

    展开全文
  • 线程同步是什么意思?为什么需要线程同步?不同步会导致什么后果? 线程同步有什么方法,接口?如何使用? 如何使用线程条件变量? 基本常识: 临界区(critical section)是指访问某一共享资源的代码片段。 ...

    Linux之线程同步——nptl线程库(二)(基础代码)

    https://mp.csdn.net/postedit/90573953

     

    提问:

    1. 线程同步是什么意思?为什么需要线程同步?不同步会导致什么后果?
    2. 线程同步有什么方法,接口?如何使用?
    3. 如何使用线程条件变量?

    基本常识:

    • 临界区(critical section)是指访问某一共享资源代码片段。
    • 原子操作(atomic operation)是指访问同一共享资源其他线程不应中断该片段执行。
    • 尽管C语言的运算符看似简单,其操作未必属于原子操作
    • 自动变量(Automatic Variable)指的是局部作用域变量
    • 死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。

     

    英文缩写与全称:

    • futex 全称为fast user space mutex 即快速用户空间互斥量。
    • mutual exclusion 即互斥。
    • condition variable 即条件变量

    1.线程同步是什么意思?为什么需要线程同步?不同步会导致什么后果?

    • 同步就是协同步调,按预定的先后次序进行运行。如进程、线程同步,可理解为进程或线程A和B一块配合,A执行到一定程度时要依靠B的某个结果,于是停下来,示意B运行;B依言执行,再将结果给A;A再继续操作。(摘自百度百科)
    • 对于为什么需要线程同步?和不同步导致的后果?可以参考基本代码中的第一个例子(链接在文章顶部)。

    2.线程同步有什么方法,接口?如何使用?

    • 线程同步的两个工具:互斥量(mutex)和条件变量(condition variable)。互斥量可以帮助线程同步对共享资源的使用,条件变量则是在此之外的拾遗补缺,允许线程相互通知共享变量的状态发生了变化。

    一、互斥量

    互斥量使用和接口

    #include<pthread.h>
    
    pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
    
    静态分配互斥量。
    
    int pthread_mutex_lock(pthread_mutex_t *mutex);
    
    锁定某一互斥量。
    成功返回0,失败返回错误号(正数)。
    参数mutex表示互斥量。
    
    int pthread_mutex_unlock(pthread_mutex_t *mutex);
    
    将某一互斥量解锁。
    成功返回0,失败返回错误号(正数)。
    参数mutex表示互斥量。
    • 对于mutex互斥量,可以理解为0锁定状态,1未锁定状态。线程1访问时,如果mutex为1,则线程让mutex减一,然后进入里面。这时候其他线程想要访问,但由于mutex为0,所以其他线程等待。直到线程1访问结束,调用pthread_mutex_unlock()让mutex加一,表示自身使用完毕。其他线程才能开始访问临界区,当然多个线程谁先访问,这是不确定的。
    • 使用案例在代码段(顶)。
    • Pthreads API 提供了 pthread_mutex_trylock()和pthread_mutex_timedlock()。这两个函数与pthread_mutex_lock()有一些区别,可以参考手册页(manual page)来使用。

    动态化初始互斥量及其销毁

    • 静态初始值PTHREAD_MUTEX_INITIALIZER,只能用于如下互斥量进行初始化:经由静态分配且携带默认属性。其他情况下,必须调用pthread_mutex_init()对互斥量进行动态初始化。
    int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t* attr);
    
    动态初始化互斥量。
    成功返回0,失败返回对应错误号。
    参数mutex为互斥量
    参数attr是指向pthread_mutexattr_t类型对象的指针,该对象在函数调用前已经经过了初始化处理,用于定义互斥量的属性。
    若将attr参数置为NULL,则互斥量的各种属性会取默认值。
    
    • SUSv3规定,初始化一个已初始化的互斥量将导致未定义的行为,应当避免这一行为。
    • 如下情况必须使用动态初始化:
    • 动态分配于堆中的互斥量。
    • 互斥量是在栈中分配的自动变量。
    • 初始化经由静态分配,且不使用默认属性的互斥量。
    int pthread_mutex_destroy(pthread_mutex_t *mutex);
    
    销毁动态分配的互斥量。
    成功返回0,失败返回对应错误号。
    
    • 当不再需要经由自动或动态分配的互斥量时,应使用pthread_mutex_destroy()将其销毁。(静态分配的不需要)
    • 只有当互斥量处于未锁定状态,且后续也无任何线程企图锁定它时,将其销毁才是安全的。若互斥量驻留于动态分配的一片内存区域中,应在释放(free)此内存区域前才将其销毁。对于自动分配的互斥量,也应在宿主函数返回前将其销毁。
    • 经由pthread_mutex_destroy()销毁的互斥量,可调用pthread_mutex_init()对其重新初始化。

    互斥量的属性

    • 由于很懒加上时间不够,而且自身也不太懂,这一段跳过(有空再来补),有兴趣可以看书或网上查。(万分抱歉)
    • 放了一个书上的例子在代码区(顶)3。

     

    二、通知状态的改变:条件变量(condition variable)

    • 互斥量防止多个线程同时访问同一共享变量。条件变量允许一个线程就某个共享变量(或其他共享资源)的状态变化通知其他线程,并让其他线程等待(堵塞于)这一通知。
    • 代码区(顶)4 提供了一个例子。表明了主线程不停地循环检查变量avail的状态,故而造成了CPU资源的浪费。采用条件变量这一问题就解决了。允许一个线程休眠直至获得另一个线程的通知(收到信号)去执行某些操作。
    • 条件变量负责就共享变量的状态改变发出通知,而互斥量提供对该共享变量访问的互斥。

    通知和等待条件变量

    int pthread_cond_singal(pthread_cond_t *cond);
    
    发出信号cond,使其他处于等待状态的线程唤醒。只保证唤醒至少一条遭到阻塞的线程。
    注意:如果先发信号,而其他线程还未进入等待,是没有用的。
    成功返回0,失败返回错误号。
    
    
    int pthread_cond_broadcase(pthread_cond_t *cond);
    
    发出信号cond,唤醒所有遭阻塞的线程。
    成功返回0,失败返回错误号。
    
    int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
    
    阻塞线程,等待信号。
    成功返回0,失败返回错误号。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 对于很多刚刚接触多线程编程的同学来说,可能仅仅听说过线程同步和线程安全这两个名词而已,对于具体什么线程同步什么是线程安全,可能也只能从他的名字上面去猜测一下他的意思,至于其他的可能并没有太多的了解...
  • 线程安全,多线程同步,异步这些概念都是什么意思例如:arraylist ,linkedlist, vector 说他们哪些是线程安全的,这个是什么意思线程安全和效率有什么联系?特别是面试的时候总是问collection set map 区别,...
  • 从程序上和逻辑上是什么意思?#1楼据我了解,同步基本上意味着编译器在您的方法周围编写了monitor.enter和monitor.exit。 因此,根据使用方式的不同,它可能是线程安全的(我的意思是,您可以使用同步方法编写对象,...
  • 理解线程同步

    2016-06-16 21:11:00
    一、为什么要线程需要同步 线程有可能和其他线程共享一些资源,比如,内存,文件,数据库等。...线程同步的真实意思,其实“排队”:几个线程之间要排队,一个一个对共享资源进行操作,而不是同时进行操作。...
  • 从程序上和逻辑上是什么意思?#1楼据我了解,同步基本上意味着编译器在您的方法周围编写了monitor.enter和monitor.exit。 因此,根据使用方式的不同,它可能是线程安全的(我的意思是,您可以使用同步方法编写对象,...
  • 如果有两个进程A和B(一般协作关系),那么进程同步意思是说,两个进程的运行过程相互制约的。相反,异步就是说两个进程各走各的,不会考虑另一个进程的状态。可想而知,两个异步运行的进程如果协作关系,...
  • java线程同步

    2018-03-19 15:24:51
    当谈起多线程的时候 都关注什么线程同步同步一词的含义就是 协同步调,按预定的先后次序进行运行 ,本来多线程并发的,但是得按照一定规则 来执行。所谓的线程切换/互斥控制/线程同步 差不多都一个意思。关于...
  • 对于很多刚刚接触多线程编程的同学来说,可能仅仅听说过线程同步和线程安全这两个名词而已,对于具体什么线程同步什么是线程安全,可能也只能从他的名字上面去猜测一下他的意思,至于其他的可能并没有太多的了解...
  • 我正在努力通过短语“类对象”来理解它们所指的是什么.什么是类对象?You might wonder what happens when a static synchronized method isinvoked, since a static method is associated with...
  • 就是线程同步意思,就是当一个程序对一个线程安全的方法或者语句进行访问的时候,其他的不能再对他进行操作了,必须等到这次访问结束以后才能对这个线程安全的方法进行访问。 什么叫线程安全: 如果你的代码所在的...
  • Linux多线程同步

    2020-10-06 21:43:42
    线程同步的作用是什么?为什么要线程同步? 关于线程同步,我认为其实并不全是原文说的意思: 所谓同步,一般是指: 多个线程同时操作一个可共享的资源变量时(如数据的增删改查), 将会导致数据不准确,相互之间...
  • 一、多线程情况下的线程安全问题先理解一个概念:线程安全:多个线程访问同一个对象时,如果不用考虑这些线程在运行时环境下的调度和交替执行,也不需要进行额外的同步,或者在调用方进行任何其他操作,调用这个对象...
  • 线程同步意思,就是当一个程序对一个线程安全的方法或者语句进行访问的时候,其 他的不能再对他进行操作了,必须等到这次访问结束以后才能对这个线程安全的方法进行访问 List item 什么叫线程安全:如果你的代码...
  • 同步、异步”这个在我们学习多线程的时候,会接触到这个概念,后面所学的一系列多线程知识运用也以这两个点开展的。由于学习的时候囫囵吞枣,导致我对这两个概念没法准确说出定义及其区别,现在记录一下。 如果...
  • java线程安全是什么

    2021-01-20 13:45:27
    就是线程同步意思,就是当一个程序对一个线程安全的方法或者语句进行访问的时候,其他的不能再对他进行操作了,必须等到这次访问结束以后才能对这个线程安全的方法进行访问 什么叫线程安全: 如果你的代码所在的...
  •  就是线程同步意思,就是当一个程序对一个线程安全的方法或者语句进行访问的时候,其他的不能再对他进行操作了,必须等到这次访问结束以后才能对这个线程安全的方法进行访问 什么叫线程安全:  如果你的代码...
  • 一般的,如果多个线程协作存、取某个变量时,一般需要用到synchronized关键字进行同步操作,如: public class MyTestThread extends MyTest implements Runnable { private boolean _done = false; public ...
  • 所谓线程同步,它的真实意思,其实“排队”,几个线程要对同一资源进行操作时,必须排队依次来进行访问,而不是在同一时刻多个线程对共享资源同时操作。   2.问题引入   至于为什么要运用线程同步呢?就如...
  • 同步 同步,字面来看,有点一起工作的意思。但在线程同步中,“同”意为协同、互相配合。 比如: A、B两个线程,并不说两个线程必须同时一起工作,而是...为什么会有线程同步?上面例子中线程A为什么要等B工...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 410
精华内容 164
关键字:

线程同步是什么意思