多线程同步

为什么要使用多线程编程？线程同步的方法主要有哪些？

多线程就象是人体一样，一直在并行的做许多工作，例如，人可以同时呼吸，血液循环，消化食物的。多线程可以将一个程序划分成多个任务，他们彼此独立的工作，以方便有效的使用处理器和用户的时间.这种比喻精辟，只要我们的机器资源够用，就要尽量提高程序的执行速度，这样能让用户感到舒服。
线程同步的方法：
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

线程同步是什么?

问题一：什么是线程同步 线程同步是指多线程通过特定的东西（如互斥量）来控制线程之间的执行顺序(同步）
也可以说是在线程之间通过同步建立起执行顺序的关系，如处没有同步那线程之间是各自运行各自的

问题二：跪求,Java里面的线程同步是个啥意思? 线程同步 在同一个线程运行 前面的运行完在运行后面的 有先后顺序
异步 是几个程序同时运行 CPU会每个程序都运行一会

问题三：java 线程同步的类和非线程同步的类有什么区别? 举例说明！不知道恰不恰当，呵呵
你来到了一个只有一个服务员和一个顾客的餐馆，由于你很饿，叫服务员过来点菜，这是服务员却说:对不起，我对这位先生的服务还没有结束。之后就不理你了。------这就是没有使用线程。
用了线程，这个服务员就可以在你和那位顾客之间进行切换，一会为你服务，一会为他服务。
线程不同步------锭位服务员正在为那位顾客服务，你却需要服务员的服务，两个人抢夺资源
线程同步---------当你看到服务员忙碌的时候，就等到他执行完当前任务的时候，在找服务员服务。

线程同步,个人觉得一般都是用在多个线程同时访问同一资源的时候！

问题四：Java 线程同步的概念 OK .
首先多线程同步的实现最终依赖锁机制。
我们可以想象某一共享资源是一间屋子，每个人都是一个线程。当A希望进入房间时，他必须获得门锁，一旦A获得门锁，他进去后就立刻将门锁上，于是B,C,D...就不得不在门外等待，直到A释放锁出来后，B,C,D...中的某一人抢到了该锁（具体抢法依赖于JVM的实现，可以先到先得，也可以随机挑选），然后进屋又将门锁上。
样，任一时刻最多有一人在屋内（使用共享资源）。

问题五：线程同步有几种实现方法,都是什么? 答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify

问题六：Java线程同步，是什么意思？ 10分 一种是方法前加sychronized
public void sychronized start() {
System.out.println(start);
}

另一种是在代码段之前加sychronized
(sychronized){
。。。。。
}

同步方法（synchronized关键字修饰的方法）可以较好地解决并发问题，在一定程度上可以避免出现资源抢占、竞争条件和死锁的情况，但其副作用是同步锁可导致线程阻塞。这要求同步方法的执行时间不能太长。

这就是所谓的锁机制，你何以使用sychronized(Object obj)锁住某个对象，等你使用完这个对象之后，再进行锁的释放，其他需要该对象的线程才可以执行。

问题七：线程的线程的同步 线程的同步是Java多线程编程的难点，往往开发者搞不清楚什么是竞争资源、什么时候需要考虑同步，怎么同步等等问题，当然，这些问题没有很明确的答案，但有些原则问题需要考虑，是否有竞争资源被同时改动的问题？对于同步，在具体的Java代码中需要完成以下两个操作：把竞争访问的资源标识为private；同步哪些修改变量的代码，使用synchronized关键字同步方法或代码。当然这不是唯一控制并发安全的途径。synchronized关键字使用说明synchronized只能标记非抽象的方法，不能标识成员变量。为了演示同步方法的使用，构建了一个信用卡账户，起初信用额为100w，然后模拟透支、存款等多个操作。显然银行账户User对象是个竞争资源，而多个并发操作的是账户方法oper(int x），当然应该在此方法上加上同步，并将账户的余额设为私有变量，禁止直接访问。工作原理线程是进程中的实体，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程不拥有系统资源，只有运行必须的一些数据结构；它与父进程的其它线程共享该进程所拥有的全部资源。线程可以创建和撤消线程，从而实现程序的并发执行。一般，线程具有就绪、阻塞和运行三种基本状态。在多中央处理器的系统里，不同线程可以同时在不同的中央处理器上运行，甚至当它们属于同一个进程时也是如此。大多数支持多处理器的操作系统都提供编程接口来让进程可以控制自己的线程与各处理器之间的关联度（affinity）。有时候，线程也称作轻量级进程。就象进程一样，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。但是，与分隔的进程相比，进程中的线程之间的隔离程度要小。它们共享内存、文件句柄和其它每个进程应有的状态。进程可以支持多个线程，它们看似同时执行，但互相之间并不同步。一个进程中的多个线程共享相同的内存地址空间，这就意味着它们可以访问相同的变量和对象，而且它们从同一堆中分配对象。尽管这让线程之间共享信息变得更容易，但您必须小心，确保它们不会妨碍同一进程里的其它线程。Java 线程工具和 API看似简单。但是，编写有效使用线程的复杂程序并不十分容易。因为有多个线程共存在相同的内存空间中并共享相同的变量，所以您必须小心，确保您的线程不会互相干扰。线程属性为了正确有效地使用线程，必须理解线程的各个方面并了解Java 实时系统。必须知道如何提供线程体、线程的生命周期、实时系统如 何调度线程、线程组、什么是幽灵线程（Demo nThread）。线程体所有的操作都发生在线程体中，在Java中线程体是从Thread类继承的run（）方法，或实现Runnable接口的类中的run（）方法。当线程产生并初始化后，实时系统调用它的run（）方法。run（）方法内的代码实现所产生线程的行为，它是线程的主要部分。线程状态附图表示了线程在它的生命周期内的任何时刻所能处的状态以及引起状态改变的方法。这图并不是完整的有限状态图，但基本概括了线程中比较感兴趣和普遍的方面。以下讨论有关线程生命周期以此为据。●新线程态（New Thread)产生一个Thread对象就生成一个新线程。当线程处于新线程状态时，仅仅是一个空线程对象，它还没有分配到系统资源。因此只能启动或终止它。任何其他操作都会引发异常。例如，一个线程调用了new方法之后，并在调用start方法之前的处于新线程状态，可以调用start和stop方法。●可运行态（Runnable)start（）方法产生运行线程所必须的资源，调度线程执行，并且调用线程的run（）方法。在这时......>>

问题八：多线程有几种实现方法，都是什么？同步有几种实现方法，都是什么 java中多线程的实现方法有两种：1.直接继承thread类；2.实现runnable接口；同步的实现方法有五种：1.同步方法；2.同步代码块；3.使用特殊域变量(volatile)实现线程同步；4.使用重入锁实现线程同步；5.使用局部变量实现线程同步 。
其中多线程实现过程中需注意重写或者覆盖run()方法，而对于同步的实现方法中使用较常使用的是利用synchronized编写同步方法和代码块。

问题九：什么是多线程以及线程同步 同步的实现方面有两种，分别是synchronized,wait与notify wait():使一个线程处于等待状态，并且释放所持有的对象的lock。 sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

问题十：多线程中的同步机制是什么，有什么优缺点 不加入线程的同步，可能导致冲突异常，不应该访问的，被访问，或者数据被无故修改

线程同步的3种方法

具体如下。互斥量：采用互斥对象机制，只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以可以保证公共资源不会被多个线程同时访问，信号量：它允许同一时刻多个线程访问同一个资源，但是需要控制同一时刻访问这个资源的最大线程数量。事件：wait/notify通过等待唤醒的方式来保持多线程的同步，还可以方便的实现多线程优先级的比较。线程(Thread)是并发程序(参见进程)中共享地址空间的并发执行单位。每个线程是一个并发执行单位，它拥有为执行计算所必须的程序代码及为程序运行所拥有的存储地址空间。一个中央处理器可以被多个线程并发地共享，而多个线程共享同一个地址空间可以为线程的分时运行和分时调度提供便利。

多线程如何同步

进程中线程同步的四种常用方式：1、 临界区（CCriticalSection）当多个线程访问一个独占性共享资源时，可以使用临界区对象。拥有临界区的线程可以访问被保护起来的资源或代码段，其他线程若想访问，则被挂起，直到拥有临界区的线程放弃临界区为止。请点击输入图片描述具体应用方式：1、 定义临界区对象CcriticalSection g_CriticalSection;2、 在访问共享资源（代码或变量）之前，先获得临界区对象，g_CriticalSection.Lock（）。请点击输入图片描述3、 访问共享资源后，则放弃临界区对象，g_CriticalSection.Unlock（）； 2、 事件（CEvent）事件机制，则允许一个线程在处理完一个任务后，主动唤醒另外一个线程执行任务。比如在某些网络应用程序中，一个线程如A负责侦听通信端口，另外一个线程B负责更新用户数据，利用事件机制，则线程A可以通知线程B何时更新用户数据。请点击输入图片描述每个Cevent对象可以有两种状态：有信号状态和无信号状态。Cevent类对象有两种类型：人工事件和自动事件。自动事件对象，在被至少一个线程释放后自动返回到无信号状态。请点击输入图片描述5人工事件对象，获得信号后，释放可利用线程，但直到调用成员函数ReSet()才将其设置为无信号状态。请点击输入图片描述

多线程如何同步

进程中线程同步的四种常用方式：1、 临界区（CCriticalSection）当多个线程访问一个独占性共享资源时，可以使用临界区对象。拥有临界区的线程可以访问被保护起来的资源或代码段，其他线程若想访问，则被挂起，直到拥有临界区的线程放弃临界区为止。请点击输入图片描述具体应用方式：1、 定义临界区对象CcriticalSection g_CriticalSection;2、 在访问共享资源（代码或变量）之前，先获得临界区对象，g_CriticalSection.Lock（）。请点击输入图片描述3、 访问共享资源后，则放弃临界区对象，g_CriticalSection.Unlock（）； 2、 事件（CEvent）事件机制，则允许一个线程在处理完一个任务后，主动唤醒另外一个线程执行任务。比如在某些网络应用程序中，一个线程如A负责侦听通信端口，另外一个线程B负责更新用户数据，利用事件机制，则线程A可以通知线程B何时更新用户数据。请点击输入图片描述每个Cevent对象可以有两种状态：有信号状态和无信号状态。Cevent类对象有两种类型：人工事件和自动事件。自动事件对象，在被至少一个线程释放后自动返回到无信号状态。请点击输入图片描述人工事件对象，获得信号后，释放可利用线程，但直到调用成员函数ReSet()才将其设置为无信号状态。请点击输入图片描述

单线程和同步 多线程和异步

线程 和 异步是两个不同的概念.
首先说线程, 线程是CUP顺序执行指令的一个调度单位.
一个线程内的指令将会被顺序执行,Ps.跳转指令也是按照时序执行的.
多线程,是指同一时刻存在多个调度单位.

异步和同步, 举个例子说明异步吧, 我要洗衣服的时候,先打开上水管,然后再去抱脏衣服,在我抱脏衣服的同时,水上好了,上水过程就相当于我打开了一个异步工作.

我们实现异步的方法基本上就是使用多线程实现的,

比如一个工作线程每秒更新显示系统时间, 而我又需要计算一个复杂的计算结果,需要耗时两秒,如果在原来的线程中执行计算方法,则无法继续正常执行更新显示系统时间的功能,因为那个代码还没执行完,无法跳转到更新时间的代码.而如果我启动另外一个线程,只需花费0.1秒,然后就可以继续执行更新显示时间的工作了,当新建的计算线程运算完毕以后,将结果返回个原线程,原线程直接将结果更新一下,就可以了. 这个过程就完成了一个典型的利用多线程进行的异步运算.

线程同步几种方式

　　进程中线程同步的四种常用方式：
　　1、 临界区（CCriticalSection）
　　当多个线程访问一个独占性共享资源时，可以使用临界区对象。拥有临界区的线程可以访问被保护起来的资源或代码段，其他线程若想访问，则被挂起，直到拥有临界区的线程放弃临界区为止。具体应用方式：
　　1、 定义临界区对象CcriticalSection g_CriticalSection;
　　2、 在访问共享资源（代码或变量）之前，先获得临界区对象，g_CriticalSection.Lock（）；
　　3、 访问共享资源后，则放弃临界区对象，g_CriticalSection.Unlock（）；
　　
　　2、 事件（CEvent）
　　事件机制，则允许一个线程在处理完一个任务后，主动唤醒另外一个线程执行任务。比如在某些网络应用程序中，一个线程如A负责侦听通信端口，另外一个线程B负责更新用户数据，利用事件机制，则线程A可以通知线程B何时更新用户数据。每个Cevent对象可以有两种状态：有信号状态和无信号状态。Cevent类对象有两种类型：人工事件和自动事件。
　　自动事件对象，在被至少一个线程释放后自动返回到无信号状态；
　　人工事件对象，获得信号后，释放可利用线程，但直到调用成员函数ReSet()才将其设置为无信号状态。在创建Cevent对象时，默认创建的是自动事件。
　　1、1234CEvent(BOOL bInitiallyOwn=FALSE, BOOL bManualReset=FALSE, LPCTSTR lpszName=NULL, LPSECURITY_ATTRIBUTES lpsaAttribute=NULL);

　　bInitiallyOwn:指定事件对象初始化状态，TRUE为有信号，FALSE为无信号；
　　bManualReset：指定要创建的事件是属于人工事件还是自动事件。TRUE为人工事件，FALSE为自动事件；
　　后两个参数一般设为NULL，在此不作过多说明。
　　2、BOOL CEvent：：SetEvent();
　　将Cevent类对象的状态设置为有信号状态。如果事件是人工事件，则Cevent类对象保持为有信号状态，直到调用成员函数ResetEvent()将其重新设为无信号状态时为止。如果为自动事件，则在SetEvent（）后将事件设置为有信号状态，由系统自动重置为无信号状态。
　　
　　3、BOOL CEvent：：ResetEvent();
　　将事件的状态设置为无信号状态，并保持该状态直至SetEvent（）被调用为止。由于自动事件是由系统自动重置，故自动事件不需要调用该函数。
　　一般通过调用WaitForSingleObject（）函数来监视事件状态。
　　
　　3、 互斥量（CMutex）
　　互斥对象和临界区对象非常相似，只是其允许在进程间使用，而临界区只限制与同一进程的各个线程之间使用，
　　但是更节省资源，更有效率。
　　4、 信号量（CSemphore）
　　当需要一个计数器来限制可以使用某共享资源的线程数目时，可以使用“信号量”对象。CSemaphore类对象保存了对当前访问某一个指定资源的线程的计数值，该计数值是当前还可以使用该资源的线程数目。如果这个计数达到了零，则所有对这个CSemaphore类对象所控制的资源的访问尝试都被放入到一个队列中等待，直到超时或计数值不为零为止。

　　
　　CSemaphore(
　　LONG lInitialCount = 1,
　　LONG lMaxCount = 1,
　　LPCTSTR pstrName = NULL,
　　LPSECURITY_ATTRIBUTES lpsaAttributes = NULL
　　);
　　
　　lInitialCount:信号量对象的初始计数值，即可访问线程数目的初始值；
　　lMaxCount：信号量对象计数值的最大值，该参数决定了同一时刻可访问由信号量保护的资源的线程最大数目；
　　后两个参数在同一进程中使用一般为NULL，不作过多讨论；
　　一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就减1，只要当前可用资源计数大于0，就可以发出信号量信号。如果为0，则放入一个队列中等待。线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore（）函数将当前可用资源数加1。

如何实现线程同步?

线程同步有几种实现方法,都是什么?
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口

同步的实现方面有两种，分别是synchronized,wait与notify
线程同步的几种方法的总结
线程同步的方式包括：互斥锁、读写锁、条件变量、信号量和令牌。互斥锁和读写锁：提供对临界资源的保护，当多线程试图访问临界资源时，都必须通过获取锁的方式来访问临界资源。（临界资源：是被多线程共享的资源）当读写线程获取锁的频率差别不大时，一般采用互斥锁，如果读线程访问临界资源的频率大于写线程，这个时候采用读写锁较为合适，读写锁允许多个读线程同时访问临界资源，读写线程必须互斥访问临界资源。读写锁的实现采用了互斥锁，所以在读写次数差不多的情况下采用读写锁性能没有直接采用互斥锁来的高。条件变量：提供线程之间的一种通知机制，当某一条件满足时，线程A可以通知阻塞在条件变量上的线程B，B所期望的条件已经满足，可以解除在条件变量上的阻塞操作，继续做其他事情。信号量：提供对临界资源的安全分配。如果存在多份临界资源，在多个线程争抢临界资源的情况下，向线程提供安全分配临界资源的方法。如果临界资源的数量为1，将退化为锁。令牌：一种高级的线程同步的方法。它既提供锁的安全访问临界资源的功能，又利用了条件变量使得线程争夺临界资源时是有序的。下面提供Token在ACE中的一种实现方法。可以从下面的类图，可以看到ACE是如何设计Token的。 ACE_Token：这个类是Token类，提供了获取和释放Token的方法。对于Token的获取策略，ACE提供两种实现：FIFO和LIFO。Token中对应着两个队列，一个是获取Token是为了写的队列，另外一个是获取Token是为了读的队列。ACE_Token_Queue：队列是一个链表，该类提供对链表的管理操作。ACE_Token_Entry：是队列中存放的元素，提供了对条件变量的封装，一个元素代表一个线程试图获取Token。如果Token已经被获取，线程需要阻塞在自己的Token上（队列Entry中的条件变量上）。等待Token持有者释放该Token，并通知阻塞的线程。 下面对ACE_Token中的组要方法提供分析。 获取判断是否有线程已经持有互斥锁了，如果没人持有，表示临界资源是可用的，那么可以立即返回成功。检查是不是线程尝试递归获取互斥锁。因为Token支持这种情况，所以也可立即返回成功。同时将nesting计数器自增。创建一个Token Entry，并将其排入队列。调用用户自定义的Hook方法，在线程进行sleep之前，用户可以调用自定义的Hook方法。线程睡眠，如果线程唤醒后，发现当前线程不是Token的拥有者将继续睡眠。线程被唤醒后，将Token entry从队列中删除。释放如果发现嵌套层数大于0，需要将嵌套层数的计数器减一，然后让该线程继续持有Token。否则，该线程负责从队列中按照一定的策略，取出Token entry，并通过该Entry通知阻塞在Entry上的线程，资源被释放，你可以使用资源了。
请用技术语言介绍下线程同步，并发操作怎么控制
现在流行的进程线程同步互斥的控制机制，其实是由最原始最基本的4种方法实现的。由这4种方法组合优化就有了.Net和Java下灵活多变的，编程简便的线程进程控制手段。



这4种方法具体定义如下 在《操作系统教程》ISBN 7-5053-6193-7 一书中可以找到更加详细的解释

1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。

2、互斥量:为协调共同对一个共享资源的单独访问而设计的。

3、信号量:为控制一个具有有限数量用户资源而设计。

4、事 件:用来通知线程有一些事件已发生，从而启动后继任务的开始。

临界区（Critical Section）

保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。

临界区包含两个操作原语：

EnterCriticalSection（） 进入临界区

LeaveCriticalSection（） 离开临界区

EnterCriticalSection（）语句执行后代码将进入临界区以后无论发生什么，必须确保与之匹配的LeaveCriticalSection（）都能够被执行到。否则临界区保护的共享资源将永远不会被释放。虽然临界区同步速度很快，但却只能用来同步本进程内的线程，而不可用来同步多个进程中的线程。

MFC提供了很多功能完备的类，我用MFC实现了临界区。MFC为临界区提供有一个CCriticalSection类，使用该类进行线程同步处理是非常简单的。只需在线程函数中用CCriticalSection类成员函数Lock（）和UnLock（）标定出被保护代码片段即可。Lock（）后代码用到的资源自动被视为临界区内的资源被保护。UnLock后别的线程才能访问这些资源。

CriticalSection

CCriticalSection global_CriticalSection;

共享资源

char global_Array[256];

初始化共享资源

void InitializeArray()

{

for(int i = 0;i<256;i++)

{

global_Array[i]=I;

}

}

写线程

UINT Global_ThreadWrite(LPVOID pParam)

{

CEdit *ptr=(CEdit *)pParam;

ptr->SetWindowText("");

进入临界区

global_CriticalSection.Lock();

for(int i = 0;i<256;i++)

{

global_Array[i]=W;

ptr->SetWindowText(global_Array);

Sleep(10);

}

离开临界区

global_CriticalSection.Unlock();

return 0;

}

删除线程

UINT Global_ThreadDelete(LPVOID pParam)

{

CEdit *ptr=(CE......>>
C语言怎么实现多线程同步
使用pthread库执行多线程，这个是Linux下的线程库 Windows下应该有自己的API，不过这种东西一般还是以Linux为标准。pthread_create()创建一个线程，传入fun()的函数指针就行了。

然后这个Beep()的需求要进行线程间通信，可以用共享内存的方法，设一个bool变量flag共享，然后beep的时候设为false，beep完设成true。fun()里面每次看一下这个flag，是false的话就不做动作等下一秒，基本可以满足需求。

这样做的好处是实现简单，但时间是以1s为单位的。如果要8秒结束立刻执行，需要用条件变量的方法来控制，比较复杂，这样的实现方式一个可以满足需求了。
Java线程同步的方法
等待唤醒机制

wait():让线程等待。将线程存储到一个线程池中。

notify()：唤醒被等待的线程。通常都唤醒线程池中的第一个。让被唤醒的线程处于临时阻塞状态。

notifyAll(): 唤醒所有的等待线程。将线程池中的所有线程都唤醒，让它们从冻结状体转到临时阻塞状态.

这三个方法用于操作线程，可是定义在了Object类中，为什么呢？

因为，这三个方法在使用时，都需要定义在同步中，要明确这些方法所操作的线程所属于锁。

简单说。在A锁被wait的线程，只能被A锁的notify方法唤醒。

所以必须要表示wait notify方法所属的锁对象，而锁对象可以是任意的对象。

可以被任意的对象调用的方法肯定弧义在Object类中。

注意：等待唤醒机制，通常都用在同步中，因为需要锁的支持。

而且必须要明确wait notify 所作用的锁对象。

JDK1.5后的锁

在jdk1.5版本之后，

出现了一些新的特性，将原理的线程进行了改良。

在java.util.concurrent.locks包中提供了一个接口Lock。替代了synchronized。

synchronized。使用的是锁操作是隐式的。

Lock接口，使用的锁操作是显示的。

由两个方法来完成：

lock():获取锁。

unlock():释放锁。

还有一个对象，Condition.

该对象的出现替代了Object中的wait notify notifyAll这些操作监视器的方法。

替代后的方式：await signal signalAll.
线程同步互斥的4种方式
临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）、事件（Event）的区别

1、临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。在任意时刻只允许一个线程对共享资源进行访问，如果有多个线程试图访问公共资源，那么在有一个线程进入后，其他试图访问公共资源的线程将被挂起，并一直等到进入临界区的线程离开，临界区在被释放后，其他线程才可以抢占。

2、互斥量：采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享

3、信号量：它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目

4、事 件： 通过通知操作的方式来保持线程的同步，还可以方便实现对多个线程的优先级比较的操作
如何实现序列化？如何实现线程的同步
在java5以前实现多线程有两种方法（继承Thread类和实现Runnable接口）

它们分别为：

使用new Thread()和new Thread(Runnable)形式

第一种直接调用thread的run方法，所以，往往使用Thread子类，即new SubThread()。

第二种调用

Runnable的run方法。

第一种：

new Thread(){}.start();这表示调用Thread子类对象的run方法，new Thread(){}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下：

new Thread(){

public void run(){

}

}.start();

第二种：

new Thread(

new Runnable(){}

).start();

这表示调用Thread对象接受的Runnable对象的run方法，new Runnable(){}表示一个Runnable的匿名子类的实例对象,

runnable的子类加上run方法后的代码如下：

new Thread(new Runnable(){

public void run(){

}

}

).start();
线程同步有几种实现方法，都是什么
继承Thread 类与实现Runnable 接口都能实现多线程

synchronized,wait 与notify 可以实现同步
实现线程同步的话在java中可以怎么实现
用synchronize关键字，可以有代码段加锁，对象加锁，方法加锁等方法实现线程同步

多线程的批量线程同步解决方案

　　多线程运行时有待处理线程？试试看下面介绍的这个批量线程同步方法吧 　　在一批线程处理程序中 有时必须等到所有线程全部运行完后 才能进行下一步任务处理 可以采用如下方法解决 创建一个锁对象 该锁对象提供一个当前线程等待其他线程的方法 见代码 　　 /** 　　 * 　　 * 此类主要用来处理线程的同步屏蔽模型 比如 一批线程运行 必须在最后一个线程运行 　　 * 完后 才能进行下一步的操作 那么就可以创建一个锁对象 锁对象提供一个线程等待其他线程 　　 * 的方法 如果当前线程运行时 还有未运行的线程 则此线程wait 否则 此线程唤醒其他阻塞的 　　 * 线程 进而最终完成线程的运行 　　 * */ 　　 public class LockObject { 　　 　　 private int totalThread = ; 　　 private int currentThread = ; 　　 　　 public LockObject(int totalThread) { 　　 this totalThread = totalThread; 　　 this currentThread = ; 　　 } 　　 　　 public synchronized void waitForOtherThread() { 　　 if (this currentThread < this totalThread) { 　　 this currentThread++; 　　 try { 　　 this wait(); 　　 } catch (InterruptedException e) { 　　 // TODO Auto generated catch block 　　 e printStackTrace(); 　　 } 　　 } else { 　　 this currentThread = ; 　　 notifyAll(); 　　 } 　　 } 　　 　　 public int getTotalThread() { 　　 return totalThread; 　　 } 　　 　　 public void setTotalThread(int totalThread) { 　　 this totalThread = totalThread; 　　 } 　　 　　 public int getCurrentThread() { 　　 return currentThread; 　　 } 　　 　　 public void setCurrentThread(int currentThread) { 　　 this currentThread = currentThread; 　　 } 　　 } 　　 　　 批量线程同步机制介绍 　　此对象提供 二个私有变量 totalThread 的初始值为所运行的线程的总数 currentThread 为当前正在运行的线程数 　　线程运行时处理完自己的任务后调用方法waitForOtherThread 等待其他线程结束 即当前运行线程数与线程总数的比较 　　如果运行线程数小于线程总数 则当前运行线程数+ 后 当前线程进入等待状态 否则 唤醒其他等待线程 　　见测试程序 　　 public class MyThread extends Thread { 　　 public static LockObject lo = new LockObject( ); 　　 　　 public MyThread(String threadName) { 　　 super(threadName); 　　 } 　　 　　 public void run() { 　　 System out println(Thread currentThread() getName() + 开始运行 ); 　　 lo waitForOtherThread(); 　　 System out println(Thread currentThread() getName() + 结束运行 ); 　　 } 　　 　　 public static void main(String[] args) { 　　 for (int i = ; i <= ; i++) { 　　 Thread thread = new MyThread( 第 + i + 个线程 ); 　　 thread setPriority(NORM_PRIORITY); 　　 thread start(); 　　 } 　　 } 　　 　　 } lishixinzhi/Article/program/Java/gj/201311/27516

Linux下线程同步的几种方法

Linux 线程同步的三种方法
线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。
一、互斥锁(mutex)
通过锁机制实现线程间的同步。
初始化锁。在Linux下，线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。
静态分配：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
动态分配：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr_t *mutexattr);
加锁。对共享资源的访问，要对互斥量进行加锁，如果互斥量已经上了锁，调用线程会阻塞，直到互斥量被解锁。
int pthread_mutex_lock(pthread_mutex *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
解锁。在完成了对共享资源的访问后，要对互斥量进行解锁。
int pthread_mutex_unlock(pthread_mutex_t *mutex);
销毁锁。锁在是使用完成后，需要进行销毁以释放资源。
int pthread_mutex_destroy(pthread_mutex *mutex);
[csharp] view plain copy
#include
#include
#include
#include
#include "iostream"
using namespace std;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int tmp;
void* thread(void *arg)
{
cout << "thread id is " << pthread_self() << endl;
pthread_mutex_lock(&mutex);
tmp = 12;
cout << "Now a is " << tmp << endl;
pthread_mutex_unlock(&mutex);
return NULL;
}
int main()
{
pthread_t id;
cout << "main thread id is " << pthread_self() << endl;
tmp = 3;
cout << "In main func tmp = " << tmp << endl;
if (!pthread_create(&id, NULL, thread, NULL))
{
cout << "Create thread success!" << endl;
}
else
{
cout << "Create thread failed!" << endl;
}
pthread_join(id, NULL);
pthread_mutex_destroy(&mutex);
return 0;
}
//编译：g++ -o thread testthread.cpp -lpthread
二、条件变量(cond)
互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。条件变量分为两部分: 条件和变量。条件本身是由互斥量保护的。线程在改变条件状态前先要锁住互斥量。条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。
初始化条件变量。
静态态初始化，pthread_cond_t cond = PTHREAD_COND_INITIALIER;
动态初始化，int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
等待条件成立。释放锁,同时阻塞等待条件变量为真才行。timewait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime);
激活条件变量。pthread_cond_signal,pthread_cond_broadcast（激活所有等待线程）
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond); //解除所有线程的阻塞
清除条件变量。无线程等待,否则返回EBUSY
int pthread_cond_destroy(pthread_cond_t *cond);
[cpp] view plain copy
#include
#include
#include "stdlib.h"
#include "unistd.h"
pthread_mutex_t mutex;
pthread_cond_t cond;
void hander(void *arg)
{
free(arg);
(void)pthread_mutex_unlock(&mutex);
}
void *thread1(void *arg)
{
pthread_cleanup_push(hander, &mutex);
while(1)
{
printf("thread1 is running\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("thread1 applied the condition\n");
pthread_mutex_unlock(&mutex);
sleep(4);
}
pthread_cleanup_pop(0);
}
void *thread2(void *arg)
{
while(1)
{
printf("thread2 is running\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("thread2 applied the condition\n");
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
int main()
{
pthread_t thid1,thid2;
printf("condition variable study!\n");
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
pthread_create(&thid1, NULL, thread1, NULL);
pthread_create(&thid2, NULL, thread2, NULL);
sleep(1);
do
{
pthread_cond_signal(&cond);
}while(1);
sleep(20);
pthread_exit(0);
return 0;
}
[cpp] view plain copy
#include
#include
#include "stdio.h"
#include "stdlib.h"
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct node
{
int n_number;
struct node *n_next;
}*head = NULL;

static void cleanup_handler(void *arg)
{
printf("Cleanup handler of second thread./n");
free(arg);
(void)pthread_mutex_unlock(&mtx);
}
static void *thread_func(void *arg)
{
struct node *p = NULL;
pthread_cleanup_push(cleanup_handler, p);
while (1)
{
//这个mutex主要是用来保证pthread_cond_wait的并发性
pthread_mutex_lock(&mtx);
while (head == NULL)
{
//这个while要特别说明一下，单个pthread_cond_wait功能很完善，为何
//这里要有一个while (head == NULL)呢？因为pthread_cond_wait里的线
//程可能会被意外唤醒，如果这个时候head != NULL，则不是我们想要的情况。
//这个时候，应该让线程继续进入pthread_cond_wait
// pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx，
//然后阻塞在等待对列里休眠，直到再次被唤醒(大多数情况下是等待的条件成立
//而被唤醒，唤醒后，该进程会先锁定先pthread_mutex_lock(&mtx);，再读取资源
//用这个流程是比较清楚的
pthread_cond_wait(&cond, &mtx);
p = head;
head = head->n_next;
printf("Got %d from front of queue/n", p->n_number);
free(p);
}
pthread_mutex_unlock(&mtx); //临界区数据操作完毕，释放互斥锁
}
pthread_cleanup_pop(0);
return 0;
}
int main(void)
{
pthread_t tid;
int i;
struct node *p;
//子线程会一直等待资源，类似生产者和消费者，但是这里的消费者可以是多个消费者，而
//不仅仅支持普通的单个消费者，这个模型虽然简单，但是很强大
pthread_create(&tid, NULL, thread_func, NULL);
sleep(1);
for (i = 0; i < 10; i++)
{
p = (struct node*)malloc(sizeof(struct node));
p->n_number = i;
pthread_mutex_lock(&mtx); //需要操作head这个临界资源，先加锁，
p->n_next = head;
head = p;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mtx); //解锁
sleep(1);
}
printf("thread 1 wanna end the line.So cancel thread 2./n");
//关于pthread_cancel，有一点额外的说明，它是从外部终止子线程，子线程会在最近的取消点，退出
//线程，而在我们的代码里，最近的取消点肯定就是pthread_cond_wait()了。
pthread_cancel(tid);
pthread_join(tid, NULL);
printf("All done -- exiting/n");
return 0;
}
三、信号量(sem)
如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。信号量函数的名字都以"sem_"打头。线程使用的基本信号量函数有四个。
信号量初始化。
int sem_init (sem_t *sem , int pshared, unsigned int value);
这是对由sem指定的信号量进行初始化，设置好它的共享选项(linux 只支持为0，即表示它是当前进程的局部信号量)，然后给它一个初始值VALUE。
等待信号量。给信号量减1，然后等待直到信号量的值大于0。
int sem_wait(sem_t *sem);
释放信号量。信号量值加1。并通知其他等待线程。
int sem_post(sem_t *sem);
销毁信号量。我们用完信号量后都它进行清理。归还占有的一切资源。
int sem_destroy(sem_t *sem);
[cpp] view plain copy
#include
#include
#include
#include
#include
#include
#define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", __func__);return;}
typedef struct _PrivInfo
{
sem_t s1;
sem_t s2;
time_t end_time;
}PrivInfo;

static void info_init (PrivInfo* thiz);
static void info_destroy (PrivInfo* thiz);
static void* pthread_func_1 (PrivInfo* thiz);
static void* pthread_func_2 (PrivInfo* thiz);

int main (int argc, char** argv)
{
pthread_t pt_1 = 0;
pthread_t pt_2 = 0;
int ret = 0;
PrivInfo* thiz = NULL;
thiz = (PrivInfo* )malloc (sizeof (PrivInfo));
if (thiz == NULL)
{
printf ("[%s]: Failed to malloc priv./n");
return -1;
}
info_init (thiz);
ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);
if (ret != 0)
{
perror ("pthread_1_create:");
}
ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);
if (ret != 0)
{
perror ("pthread_2_create:");
}
pthread_join (pt_1, NULL);
pthread_join (pt_2, NULL);
info_destroy (thiz);
return 0;
}
static void info_init (PrivInfo* thiz)
{
return_if_fail (thiz != NULL);
thiz->end_time = time(NULL) + 10;
sem_init (&thiz->s1, 0, 1);
sem_init (&thiz->s2, 0, 0);
return;
}
static void info_destroy (PrivInfo* thiz)
{
return_if_fail (thiz != NULL);
sem_destroy (&thiz->s1);
sem_destroy (&thiz->s2);
free (thiz);
thiz = NULL;
return;
}
static void* pthread_func_1 (PrivInfo* thiz)
{
return_if_fail(thiz != NULL);
while (time(NULL) end_time)
{
sem_wait (&thiz->s2);
printf ("pthread1: pthread1 get the lock./n");
sem_post (&thiz->s1);
printf ("pthread1: pthread1 unlock/n");
sleep (1);
}
return;
}
static void* pthread_func_2 (PrivInfo* thiz)
{
return_if_fail (thiz != NULL);
while (time (NULL) end_time)
{
sem_wait (&thiz->s1);
printf ("pthread2: pthread2 get the unlock./n");
sem_post (&thiz->s2);
printf ("pthread2: pthread2 unlock./n");
sleep (1);
}
return;
}

Linux 线程同步有哪些方法？

Linux系统中，实现线程同步的方式大致分为六种，其中包括：互斥锁、自旋锁、信号量、条件变量、读写锁、屏障。最常用的线程同步方式就是互斥锁、自旋锁、信号量：1、互斥锁互斥锁本质就是一个特殊的全局变量，拥有lock和unlock两种状态，unlock的互斥锁可以由某个线程获得，当互斥锁由某个线程持有后，这个互斥锁会锁上变成lock状态，此后只有该线程有权力打开该锁，其他想要获得该互斥锁的线程都会阻塞，直到互斥锁被解锁。互斥锁的类型：①普通锁：互斥锁默认类型。当一个线程对一个普通锁加锁以后，其余请求该锁的线程将形成一个等待队列，并在锁解锁后按照优先级获得它，这种锁类型保证了资源分配的公平性。一个线程如果对一个已经加锁的普通锁再次加锁，将引发死锁;对一个已经被其他线程加锁的普通锁解锁，或者对一个已经解锁的普通锁再次解锁，将导致不可预期的后果。②检错锁：一个线程如果对一个已经加锁的检错锁再次加锁，则加锁操作返回EDEADLK;对一个已经被其他线程加锁的检错锁解锁或者对一个已经解锁的检错锁再次解锁，则解锁操作返回EPERM。③嵌套锁：该锁允许一个线程在释放锁之前多次对它加锁而不发生死锁;其他线程要获得这个锁，则当前锁的拥有者必须执行多次解锁操作;对一个已经被其他线程加锁的嵌套锁解锁，或者对一个已经解锁的嵌套锁再次解锁，则解锁操作返回EPERM。④默认锁：一个线程如果对一个已经解锁的默认锁再次加锁，或者对一个已经被其他线程加锁的默认锁解锁，或者对一个解锁的默认锁解锁，将导致不可预期的后果;这种锁实现的时候可能被映射成上述三种锁之一。【老男孩教育】Linux运维云计算课程汇集了虚拟化、云计算、安全攻防、Python开发、SRE等技术，课堂效率高、内容丰富全面，由浅入深，循序渐进，帮助学员稳扎稳打，夯实基础，在有限的时间内帮助学员高效提升，成为符合企业需求的技术型人才。2、自旋锁自旋锁顾名思义就是一个死循环，不停的轮询，当一个线程未获得自旋锁时，不会像互斥锁一样进入阻塞休眠状态，而是不停的轮询获取锁，如果自旋锁能够很快被释放，那么性能就会很高，如果自旋锁长时间不能够被释放，甚至里面还有大量的IO阻塞，就会导致其他获取锁的线程一直空轮询，导致CPU使用率达到100%，特别CPU时间。3、信号量信号量是一个计数器，用于控制访问有限共享资源的线程数。

java中线程同步的几种方法

线程同步主要有以下种方法(示例中是实现计数的功能)：1、同步方法，即使用synchronized关键字修饰方法，例如：public synchronized void add(int c){...}2、同步代码块，即有synchronized关键字修饰的语句块，例如：public void addAndGet(int c){ synchronized(this){ count += c; }}3、使用特殊域变量(volatile)实现线程同步，该方法不能保证绝对的同步。例如：private volatile int count = 0;4、使用锁实现线程同步，例如：private Lock lock = new ReentrantLock(); public void add(int c) { lock.lock();//上锁 try{ count += c; }finally{ lock.unlock();//解锁 } }5、使用原子变量实现线程同步，在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，例如：private AtomicInteger count= new AtomicInteger(1);public void add(int c) { count.addAndGet(c);}6、使用局部变量实现线程同步，如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本， 副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。ThreadLocal 类的常用方法new ThreadLocal() : 创建一个线程本地变量get() : 返回此线程局部变量的当前线程副本中的值initialValue() : 返回此线程局部变量的当前线程的"初始值"set(T value) : 将此线程局部变量的当前线程副本中的值设置为value示例代码：private static ThreadLocal count= new ThreadLocal(){ @Override protected Integer initialValue(){ return 1; } }; public void add(int c){ count.set(count.get() + c); }7、使用阻塞队列实现，例如LinkedBlockingQueue，具体使用可百度LinkedBlockingQueue的用法或查看java文档。

JAVA中线程同步方法有哪些

JAVA中线程同步方法一般有以下三种：
1 wait方法：
该方法属于Object的方法，wait方法的作用是使得当前调用wait方法所在部分（代码块）的线程停止执行，并释放当前获得的调用wait所在的代码块的锁，并在其他线程调用notify或者notifyAll方法时恢复到竞争锁状态（一旦获得锁就恢复执行）。
调用wait方法需要注意几点：
第一点：wait被调用的时候必须在拥有锁（即synchronized修饰的）的代码块中。
第二点：恢复执行后，从wait的下一条语句开始执行，因而wait方法总是应当在while循环中调用，以免出现恢复执行后继续执行的条件不满足却继续执行的情况。
第三点：若wait方法参数中带时间，则除了notify和notifyAll被调用能激活处于wait状态（等待状态）的线程进入锁竞争外，在其他线程中interrupt它或者参数时间到了之后，该线程也将被激活到竞争状态。
第四点：wait方法被调用的线程必须获得之前执行到wait时释放掉的锁重新获得才能够恢复执行。
2 notify方法和notifyAll方法：
notify方法通知调用了wait方法，但是尚未激活的一个线程进入线程调度队列（即进入锁竞争），注意不是立即执行。并且具体是哪一个线程不能保证。另外一点就是被唤醒的这个线程一定是在等待wait所释放的锁。
notifyAll方法则唤醒所有调用了wait方法，尚未激活的进程进入竞争队列。
3 synchronized关键字：
第一点：synchronized用来标识一个普通方法时，表示一个线程要执行该方法，必须取得该方法所在的对象的锁。
第二点：synchronized用来标识一个静态方法时，表示一个线程要执行该方法，必须获得该方法所在的类的类锁。
第三点：synchronized修饰一个代码块。类似这样：synchronized(obj) { //code.... }。表示一个线程要执行该代码块，必须获得obj的锁。这样做的目的是减小锁的粒度，保证当不同块所需的锁不冲突时不用对整个对象加锁。利用零长度的byte数组对象做obj非常经济。