java并发问题概述

public class Test{public synchronized void print(){….;}
}

public class Test{public void print(){synchronized(this){//锁住本对象 …;}}
}

public class Test{private String a = “test”;public void print(){synchronized(a){//锁住a对象 …;}}public synchronized void t(){…;//这个同步代码块不会因为print()而锁定.}
}

public class Test{private byte[] lock = new byte[0];public void print(){synchronized(lock){…;}}public synchronized void t(){…;}
}

public class Test{public synchronized static void execute(){…;}
}

public class Test{public static void execute(){synchronized(TestThread.class){…;}}
}

public class MyStack {int idx = 0;char [] data = new char[6];public synchronized void push(char c) {data[idx] = c;idx++;}public synchronized char pop() {idx--;return data[idx];}public static void main(String args[]){MyStack m = new MyStack();/**下面对象m被加锁。严格的说是对象m的所有synchronized块被加锁。如果存在另一个试图访问m的线程T，那么T无法执行m对象的push和pop方法。*/m.pop();//对象m被加锁。}
}

MyStatckm1=newMyStack();
MyStatckm2=newMystatck();
m1.pop();
m2.pop();

public synchronized char pop() {char c;while (buffer.size() == 0) {try {this.wait();//从厕位里出来}catch (InterruptedException e) {// ignore it…}}c = ((Character)buffer.remove(buffer.size()-1)). charValue();return c;
}
public synchronized void push(char c) {this.notify();//通知那些wait()的线程重新排队。注意：仅仅是通知它们重新排队。 Character charObj = new Character(c);buffer.addElement(charObj);
}
//执行完毕，释放锁。那些排队的线程就可以进来了。

class BoundedBuffer {final Lock lock = new ReentrantLock();final Condition notFull = lock.newCondition();final Condition notEmpty = lock.newCondition();final Object[] items = new Object[100];int putptr, takeptr, count;public void put(Object x) throws InterruptedException {lock.lock();try {while (count == items.length) notFull.await();items[putptr] = x;if (++putptr == items.length) putptr = 0;++count;notEmpty.signal();}finally {lock.unlock();}}public Object take() throws InterruptedException {lock.lock();try {while (count == 0) notEmpty.await();Object x = items[takeptr];if (++takeptr == items.length) takeptr = 0;--count;notFull.signal();return x;}finally {lock.unlock();}}
}

package io;
import java.io.*;
public class PipedStreamTest {public static void main(String[] args) {PipedOutputStream ops=new PipedOutputStream();PipedInputStream pis=new PipedInputStream();try{ops.connect(pis);//实现管道连接 new Producer(ops).run();new Consumer(pis).run();}catch(Exception e){e.printStackTrace();}}
}
//生产者 
class Producer implements Runnable{private PipedOutputStream ops;public Producer(PipedOutputStream ops) {this.ops=ops;}public void run(){try{ops.write("hell,spell".getBytes());ops.close();}catch(Exception e){e.printStackTrace();}}
}
//消费者 
class Consumer implements Runnable{private PipedInputStream pis;public Consumer(PipedInputStream pis) {this.pis=pis;}public void run(){try{byte[] bu=new byte[100];int len=pis.read(bu);System.out.println(new String(bu,0,len));pis.close();}catch(Exception e){e.printStackTrace();}}
}

package io;
import java.io.*;
public class PipedStreamTest {public static void main(String[] args) {PipedOutputStream ops=new PipedOutputStream();PipedInputStream pis=new PipedInputStream();try{ops.connect(pis);//实现管道连接 Producer p = new Producer(ops);new Thread(p).start();Consumer c = new Consumer(pis);new Thread(c).start();}catch(Exception e){e.printStackTrace();}}
}
//生产者 
class Producer implements Runnable{private PipedOutputStream ops;public Producer(PipedOutputStream ops) {this.ops=ops;}public void run(){try{for (;;){ops.write("hell,spell".getBytes());ops.close();}}catch(Exception e){e.printStackTrace();}}
}
//消费者 
class Consumer implements Runnable{private PipedInputStream pis;public Consumer(PipedInputStream pis) {this.pis=pis;}public void run(){try{for (;;){byte[] bu=new byte[100];int len=pis.read(bu);System.out.println(new String(bu,0,len));}pis.close();}catch(Exception e){e.printStackTrace();}}
}

import java.io.*;
public class PipedIO {//程序运行后将sendFile文件的内容拷贝到receiverFile文件中 public static void main(String args[]){try{//构造读写的管道流对象 PipedInputStream pis=new PipedInputStream();PipedOutputStream pos=new PipedOutputStream();//实现关联 pos.connect(pis);//构造两个线程，并且启动。 new Sender(pos,”c:\text2.txt”).start();new Receiver(pis,”c:\text3.txt”).start();}catch(IOException e){System.out.println(“Pipe Error”+ e);}}
}
//线程发送 
class Sender extends Thread{PipedOutputStream pos;File file;//构造方法 Sender(PipedOutputStream pos, String fileName){this.pos=pos;file=new File(fileName);}//线程运行方法 public void run(){try{//读文件内容 FileInputStream fs=new FileInputStream(file);int data;while((data=fs.read())!=-1){//写入管道始端 pos.write(data);}pos.close();}catch(IOException e) {System.out.println(“Sender Error” +e);}}
}
//线程读 
class Receiver extends Thread{PipedInputStream pis;File file;//构造方法 Receiver(PipedInputStream pis, String fileName){this.pis=pis;file=new File(fileName);}//线程运行 public void run(){try {//写文件流对象 FileOutputStream fs=new FileOutputStream(file);int data;//从管道末端读 while((data=pis.read())!=-1){//写入本地文件    fs.write(data);}pis.close();}catch(IOException e){System.out.println("Receiver Error" +e);}}
}

BlockingQueue blockingQ = new ArrayBlockingQueue 10; 

for(;;){ 
Object o = blockingQ.take();//队列为空，则等待（阻塞） 
} 

for(;;){ 
blockingQ.put(new Object());//队列满，则等待（阻塞） 
} 

Executor executor = anExecutor;//生成一个Executor实例。 
executor.execute(new RunnableTask1()); 

class NetworkService {private final ServerSocket serverSocket;private final ExecutorService pool;public NetworkService(int port, int poolSize) throws IOException {serverSocket = new ServerSocket(port);pool = Executors.newFixedThreadPool(poolSize);}public void serve() {try {for (;;) {pool.execute(new Handler(serverSocket.accept()));}}catch (IOException ex) {pool.shutdown();//不再执行新任务}}
}
class Handler implements Runnable {private final Socket socket;Handler(Socket socket) {this.socket = socket;}public void run() {// read and service request}
}

public static void main(String args[])throws Exception {ExecutorService executor = Executors.newSingleThreadExecutor();Callable task = new Callable(){public String call()throws Exception{return “test”;}};Future f = executor.submit(task);String result = f.get();//等待（阻塞）返回结果 System.out.println(result);executor.shutdown();
}

executor.submit(task1); 
executor.submit(task2); 

public static void main(String[] args)throws Exception {// TODO Auto-generated method stub final int count=10;final CountDownLatch completeLatch = new CountDownLatch(count);//定义了门插销的数目是10for (int i=0;i<count;i++){Thread thread = new Thread("worker thread"+i){public void run(){//do xxxx                  completeLatch.countDown();//减少一根门插销}};thread.start();}completeLatch.await();//如果门插销还没减完则等待。
}

public static void main(String[] args) throws Exception {// TODO Auto-generated method stub final CountDownLatch startLatch = new CountDownLatch(1);//定义了一根门插销for (int i = 0; i < 10; i++) {Thread thread = new Thread("worker thread" + i) {public void run() {try {startLatch.await();//如果门插销还没减完则等待}catch (InterruptedException e) {}// do xxxx}};thread.start();}startLatch.countDown();//减少一根门插销
}

public class CycliBarrierTest implements Runnable {private CyclicBarrier barrier;public CycliBarrierTest(CyclicBarrier barrier) {this.barrier = barrier;}public void run() {//do xxxx;try {this.barrier.await();//线程运行至此会检查是否其它线程都到齐了，没到齐就继续等待。到齐了就执行barrier的run函数体里的内容}catch (Exception e) {}}/*** @param args*/public static void main(String[] args) {//参数2代表两个线程都达到起跑线才开始一起继续往下执行CyclicBarrier barrier = new CyclicBarrier(2, new Runnable() {public void run() {//do xxxx;}});Thread t1 = new Thread(new CycliBarrierTest(barrier));Thread t2 = new Thread(new CycliBarrierTest(barrier));t1.start();t2.start();}
}