本文目录一览：
Java中线程怎么同步
1、使用线程类自带的join方法，将子线程加入到主线程，在子线程执行完之后，在执行主线程逻辑。
例如
[java] view plain copy
public static void joinDemo()
throws InterruptedException
{
System.out.println("=========Test with join=====");
JoinWorker worker1 = new JoinWorker("worker1");
JoinWorker worker2 = new JoinWorker("worker2");
worker1.start();
worker2.start();
worker1.join();
worker2.join();
doSuperWork();
}
2、使用JDK的并发包中的CountDownLatch类， 使用CountDownLatch，每个线程调用其countDown方法使计数器-1，主线程调用await方法阻塞等待，直到CountDownLatch计数器为0时继续执行，例如
首先，定义子线程
[java] view plain copy
static class CountDownLatchWorker extends Thread
{
String workerName;
CountDownLatch latch;
public CountDownLatchWorker(String workerName, CountDownLatch latch)
{
this.workerName = workerName;
this.latch = latch;
}
public void run()
{
System.out.println("Sub Worker " + workerName + " do work begin at "
+ sdf.format(new Date()));
new ThreadWaitDemo().doSomeWork();// 做实际工作
System.out.println("Sub Worker " + workerName + " do work complete at "
+ sdf.format(new Date()));
latch.countDown();// 完成之后，计数器减一
}
}
主线程中调研await方法阻塞等待，直到所有线程完成
[html] view plain copy
public static void countDownLatchDemo()
throws InterruptedException
{
System.out.println("=========Test with CountDownLatch=====");
CountDownLatch latch = new CountDownLatch(2);
CountDownLatchWorker worker1 = new CountDownLatchWorker("worker1", latch);
CountDownLatchWorker worker2 = new CountDownLatchWorker("worker2", latch);
worker1.start();
worker2.start();
//主线程阻塞等待
latch.await();
doSuperWork();
}
3、使用JDK并发包CyclicBarrier，CyclicBarrier类似于CountDownLatch也是个计数器， 不同的是CyclicBarrier的await()方法没被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此 CyclicBarrier 上面阻塞的线程开始运行。 在这之后，如果再次调用 await()方法，计数就又会变成 N-1，新一轮重新开始CyclicBarrier初始时还可带一个Runnable的参数，此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。
示例如下
[java] view plain copy
public static void cyclicBarrierDemo()
throws InterruptedException, BrokenBarrierException
{
System.out.println("=========Test with CyclicBarrier=====");
CyclicBarrier cb = new CyclicBarrier(2, new Runnable()
{
// 将主线程业务放到CyclicBarrier构造方法中，所有线程都到达Barrier时执行
@SuppressWarnings("static-access")
public void run()
{
new ThreadWaitDemo().doSuperWork();
}
});// 设定需要等待两个线程
ExecutorService executor = Executors.newFixedThreadPool(2);
CyclicBarrierWorker worker1 = new CyclicBarrierWorker("worker1", cb);
CyclicBarrierWorker worker2 = new CyclicBarrierWorker("worker2", cb);
executor.execute(worker1);
executor.execute(worker2);
executor.shutdown();
}
4、使用JDK并发包中的Executors框架，ExecutorService的的invokeAll方法调研callable集合，批量执行多个线程，在invokeAll方法结束之后，再执行主线程其他业务逻辑
示例如下
[java] view plain copy
public static void callableDemo()
throws InterruptedException
{
System.out.println("=========Test with Callable=====");
ListCallableInteger callList = new ArrayListCallableInteger();
ExecutorService exec = Executors.newFixedThreadPool(2);
// 采用匿名内部类实现
callList.add(new CallableInteger()
{
public Integer call()
throws Exception
{
System.out.println("Sub Worker worker1 do work begin at " + sdf.format(new Date()));
new ThreadWaitDemo().doSomeWork();// 做实际工作
System.out.println("Sub Worker worker1 do work complete at "
+ sdf.format(new Date()));
return 0;
}
});
callList.add(new CallableInteger()
{
public Integer call()
throws Exception
{
System.out.println("Sub Worker worker2 do work begin at " + sdf.format(new Date()));
new ThreadWaitDemo().doSomeWork();// 做实际工作
System.out.println("Sub Worker worker2 do work complete at "
+ sdf.format(new Date()));
return 0;
}
});
exec.invokeAll(callList);
exec.shutdown();
doSuperWork();
}
5、这种过于恶心，只简单说一下方法，主线程创建一个线程List，将每个子线程保存到列表中，然后定期轮询列表中子线程状态，当所有线程都完成之后，再执行主线程逻辑
简单写出线程同步的方法（java）
/**
* Java线程：线程的同步
*
* @author leizhimin 2009-11-4 11:23:32
*/
public class Test {
public static void main(String[] args) {
User u = new User("张三", 100);
MyThread t1 = new MyThread("线程A", u, 20);
MyThread t2 = new MyThread("线程B", u, -60);
MyThread t3 = new MyThread("线程C", u, -80);
MyThread t4 = new MyThread("线程D", u, -30);
MyThread t5 = new MyThread("线程E", u, 32);
MyThread t6 = new MyThread("线程F", u, 21);
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
}
}
class MyThread extends Thread {
private User u;
private int y = 0;
MyThread(String name, User u, int y) {
super(name);
this.u = u;
this.y = y;
}
public void run() {
u.oper(y);
}
}
class User {
private String code;
private int cash;
User(String code, int cash) {
this.code = code;
this.cash = cash;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
/**
* 业务方法
* @param x 添加x万元
*/
public synchronized void oper(int x) {
try {
Thread.sleep(10L);
this.cash += x;
System.out.println(Thread.currentThread().getName() + "运行结束，增加“" + x + "”，当前用户账户余额为：" + cash);
Thread.sleep(10L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public String toString() {
return "User{" +
"code='" + code + '\'' +
", cash=" + cash + '}';
}
}
输出结果：线程A运行结束，增加“20”，当前用户账户余额为：120
线程F运行结束，增加"21"，当前用户账户余额为：141
线程E运行结束，增加"32"，当前用户账户余额为：173
线程C运行结束，增加"-80"，当前用户账户余额为：93
线程B运行结束，增加"-60"，当前用户账户余额为：33
线程D运行结束，增加"-30"，当前用户账户余额为：3
Process finished with exit code 0反面教材，不同步的情况，也就是去掉oper(int x)方法的synchronized修饰符，然后运行程序，结果如下：线程A运行结束，增加"20"，当前用户账户余额为：61
线程D运行结束，增加"-30"，当前用户账户余额为：63
线程B运行结束，增加"-60"，当前用户账户余额为：3
线程F运行结束，增加"21"，当前用户账户余额为：61
线程E运行结束，增加"32"，当前用户账户余额为：93
线程C运行结束，增加"-80"，当前用户账户余额为：61
Process finished with exit code 0很显然，上面的结果是错误的，导致错误的原因是多个线程并发访问了竞争资源u，并对u的属性做了改动。可见同步的重要性。注意：通过前文可知，线程退出同步方法时将释放掉方法所属对象的锁，但还应该注意的是，同步方法中还可以使用特定的方法对线程进行调度。这些方法来自于java.lang.Object类。
void notify()
唤醒在此对象监视器上等待的单个线程。
void notifyAll()
唤醒在此对象监视器上等待的所有线程。
void wait()
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
void wait(long timeout)
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。
void wait(long timeout, int nanos)
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。
Java如何实现多线程同步？
//解决方案-1 设置3把锁, 然后把锁们应用到所有线程中 (涉及到synchronized wait notify等, 嫌麻烦. 略)
解决方案-2 设置3个全局共享的信号标记(信号灯) + 3子线程分别占用标记1 2 3
+ 主线程轮询/等待
(简洁明快 推荐)
//解决方案-2 实现如下:
static boolean t1_done = false;
static boolean t2_done = false;
static boolean t3_done = false;
//t1------run() { ............ ; t1_done = true; }
//t2、 3: 同理,略
main () { .............;
启动t1;
启动t2;
启动t3;
//轮询 or 等待
while ( true )
if ( t1_done t2_done t3_done) break;
else
Thread.yield () ;
// 或 Thread.sleep(xxxx) ----若子线程运行超过100ms以上,应予考虑
//轮询结束,主线程继续工作
} //main END
have fun
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.
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 ThreadLocalT() : 创建一个线程本地变量
get() : 返回此线程局部变量的当前线程副本中的值
initialValue() : 返回此线程局部变量的当前线程的"初始值"
set(T value) : 将此线程局部变量的当前线程副本中的值设置为value
示例代码：
private static ThreadLocalInteger count= new ThreadLocalInteger(){
@Override
protected Integer initialValue(){
return 1;
}
};
public void add(int c){
count.set(count.get() + c);
}
7、使用阻塞队列实现，例如LinkedBlockingQueue，具体使用可百度LinkedBlockingQueue的用法或查看java文档。
