Java中的多线程编程

一、多线程的优缺点

多线程的优点：

1）资源利用率更好2）程序设计在某些情况下更简单3）程序响应更快

多线程的代价：

1）设计更复杂虽然有一些多线程应用程序比单线程的应用程序要简单，但其他的一般都更复杂。在多线程访问共享数据的时候，这部分代码需要特别的注意。线程之间的交互往往非常复杂。不正确的线程同步产生的错误非常难以被发现，并且重现以修复。

2）上下文切换的开销当CPU从执行一个线程切换到执行另外一个线程的时候，它需要先存储当前线程的本地的数据，程序指针等，然后载入另一个线程的本地数据，程序指针等，最后才开始执行。这种切换称为“上下文切换”(“context switch”)。CPU会在一个上下文中执行一个线程，然后切换到另外一个上下文中执行另外一个线程。上下文切换并不廉价。如果没有必要，应该减少上下文切换的发生。

二、创建java多线程

1、创建Thread的子类

创建Thread子类的一个实例并重写run方法，run方法会在调用start()方法之后被执行。例子如下：

public class MyThread extends Thread {
   public void run(){
     System.out.println("MyThread running");
   }
}
MyThread myThread = new MyThread();

myTread.start();

public class MyClass {

public synchronized void log1(String msg1,String msg2){
log.writeln(msg1);
log.writeln(msg2);
}

public void log2(String msg1,String msg2){
synchronized(this){
log.writeln(msg1);
log.writeln(msg2);
}
}
}

public class MyClass { public static synchronized void log1(String msg1,String msg2){ log.writeln(msg1); log.writeln(msg2); }

public static void log2(String msg1,String msg2){
   synchronized(MyClass.class){
      log.writeln(msg1);
      log.writeln(msg2);
   }
}

}

public class MyWaitNotify{

MonitorObject myMonitorObject = new MonitorObject();
boolean wasSignalled = false;

public void doWait(){
synchronized(myMonitorObject){
while(!wasSignalled){
try{
myMonitorObject.wait();
} catch(InterruptedException e){...}
}
//clear signal and continue running.
wasSignalled = false;
}
}

public void doNotify(){
synchronized(myMonitorObject){
wasSignalled = true;
myMonitorObject.notify();
}
}
}

public class Lock { boolean isLocked = false; Thread lockedBy = null; int lockedCount = 0;

public synchronized void lock() throws InterruptedException{
    Thread callingThread = Thread.currentThread();
    while(isLocked &amp;&amp; lockedBy != callingThread){
        wait();
    }
    isLocked = true;
    lockedCount++;
    lockedBy = callingThread;
}

public synchronized void unlock(){
    if(Thread.currentThread() == this.lockedBy){
        lockedCount--;
        if(lockedCount == 0){
            isLocked = false;
            notify();
        }
    }
}

}

public class BlockingQueue { private List queue = new LinkedList(); private int limit = 10;

public BlockingQueue(int limit) {
    this.limit = limit;
}

public synchronized void enqueue(Object item) throws InterruptedException {
    while (this.queue.size() == this.limit) {
        wait();
    }
    if (this.queue.size() == 0) {
        notifyAll();
    }
    this.queue.add(item);
}

public synchronized Object dequeue() throws InterruptedException {
    while (this.queue.size() == 0) {
        wait();
    }
    if (this.queue.size() == this.limit) {
        notifyAll();
    }
    return this.queue.remove(0);
}

}

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;

public class Main {
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
cachedThreadPool.execute(new Runnable() {
public void run() {
System.out.println(index);
}
});
}
}
}

Java中的 多线程编程

相关推荐

Java中的多线程编程