线程

线程同步两种方法

1.synchronized代码块 (指定同步标记对象，也可以是this)  对象监视器

2.synchronized同步函数 (默认标记的对象是this)

代码块与同步函数的同步 标记对象为this就可以了

//生产者

class Factory implements Runnable

{

Q q;

public Factory (Q q)

{

this.q = q;

}

public void run()

{

while (true)

{

Sychronized(q)

{

.......q.name = "";

.....q.sex = "";

}

}

}

}

//消费者

class Consumer implements Runnable

{

Q q;

public Consumer(Q q)

{

this.q = q;

}

public void run()

{

while(true)

{

synchronized (q)

{

System.out.print(q.name);

System.out.println(q.sex);

}

}

}

}

class Q

{

String name = "unknown";

String sex = "unknown";

}

class Test

{

Q q = new Q();

new Thread(new Producer(q)).start();

new Thread(new Consumer(q)).start();

}

wait  告诉当前线程放弃监视器并进入睡眠状态，直到其他线程进入同一监视器并调用notify为止

notify  

notifyAll  

Synchronized(o) 线程t 得到对象o的lock标记后，

o.wait()  此时线程被放置到对象o的等待线程池中，t自动释放o的锁标记

o.notify()  线程可能会被从o的等待线程池中释放，当t得到标记时就会执行下去

java5原子性操作类的应用

AutomicInteger

AutomicBoolean

AutomicLong

.....

java5的线程锁技术 Lock

java5条件阻塞Condition

java5的Semaphere同步工具

java5的CyclicBarrier同步工具

java5的CountDownLatch同步工具

java5的Exchanger同步工具

java5阻塞队列的应用 

java.util.concurrent 
Class ArrayBlockingQueue<E>

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;


public class BlockingQueueTest {
public static void main(String[] args) {
final BlockingQueue queue = new ArrayBlockingQueue(3);
for(int i=0;i<2;i++){
new Thread(){
public void run(){
while(true){
try {
Thread.sleep((long)(Math.random()*1000));
System.out.println(Thread.currentThread().getName() + "准备放数据!");
queue.put(1);
System.out.println(Thread.currentThread().getName() + "已经放了数据，" +
"队列目前有" + queue.size() + "个数据");
} catch (InterruptedException e) {
e.printStackTrace();
}


}
}

}.start();
}

new Thread(){
public void run(){
while(true){
try {
//将此处的睡眠时间分别改为100和1000，观察运行结果
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "准备取数据!");
queue.take();
System.out.println(Thread.currentThread().getName() + "已经取走数据，" +
"队列目前有" + queue.size() + "个数据");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

}.start();
}
}

import java.util.Collections;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;


public class BlockingQueueCommunication {


/**
* @param args
*/
public static void main(String[] args) {

final Business business = new Business();
new Thread(
new Runnable() {

@Override
public void run() {

for(int i=1;i<=50;i++){
business.sub(i);
}

}
}
).start();

for(int i=1;i<=50;i++){
business.main(i);
}

}


static class Business {
 
 
 BlockingQueue<Integer> queue1 = new ArrayBlockingQueue<Integer>(1);
 BlockingQueue<Integer> queue2 = new ArrayBlockingQueue<Integer>(1);
 
 {
 Collections.synchronizedMap(null);
 try {
 System.out.println("xxxxxdfsdsafdsa");
queue2.put(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 }
 
 public  void sub(int i){
  try {
queue1.put(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for(int j=1;j<=10;j++){
System.out.println("sub thread sequece of " + j + ",loop of " + i);
}
try {
queue2.take();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 }
 
 public  void main(int i){
  try {
queue2.put(1);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
for(int j=1;j<=100;j++){
System.out.println("main thread sequece of " + j + ",loop of " + i);
}
try {
queue1.take();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 }
 }


}