java基础笔记04

多线程

线程生命周期：new→start()→run()→sleep(),wait()→dead

1、线程同步，thread synchronization：当多个线程需要使用同一个资源时，有可能造成结果紊乱。需要使用同步的方法来使某一时刻，某一资源只被一个线程使用。java中每一个object都与一个monitor联系起来，线程将锁住或解锁monitor。一个object的monitor每次只有一个thread可以对其加锁。java使用synchronized对线程共享的资源进行分配，当某一线程锁住共享资源时，只有当该线程完成时才把共享资源解锁，并将锁交给下一个需要使用共享资源的线程。

class PrintDemo {
public void printCount(){
try {
for(int i = 5; i > 0; i--) {
System.out.println("Counter   ---   "  + i );
}
} catch (Exception e) {
System.out.println("Thread  interrupted.");
}
}

}

class ThreadDemo extends Thread {
private Thread t;
private String threadName;
PrintDemo  PD;

ThreadDemo( String name,  PrintDemo pd){
threadName = name;
PD = pd;
}
public void run() {
synchronized(PD) {
PD.printCount();
}
System.out.println("Thread " +  threadName + " exiting.");
}

public void start ()
{
System.out.println("Starting " +  threadName );
if (t == null)
{
t = new Thread (this, threadName);
t.start ();
}
}

}

public class TestThread {
public static void main(String args[]) {

PrintDemo PD = new PrintDemo();

ThreadDemo T1 = new ThreadDemo( "Thread - 1 ", PD );
ThreadDemo T2 = new ThreadDemo( "Thread - 2 ", PD );

T1.start();
T2.start();

// wait for threads to end
try {
T1.join();
T2.join();
} catch( Exception e) {
System.out.println("Interrupted");
}
}
}

输出结果：

Starting Thread - 1
Starting Thread - 2
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 1  exiting.
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 2  exiting.

2、线程间的通信：
wait(): 暂停当前线程，进入另一个需要使用该对象为共享资源的线程；

notify(): 唤醒一个被暂停的线程。

class Chat {
boolean flag = false;
int sum = 0;

public synchronized void Question(String msg) {

if (flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Question: sum ="+this.sum+", "+msg);
flag = true;
notify();

}

public synchronized void Answer(String msg) {

if (!flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Answer: sum ="+this.sum+", "+msg);
flag = false;
notify();

}
}

class T1 implements Runnable {
Chat m;
String[] s1 = { "Hi", "How are you ?", "I am also doing fine!" };

public T1(Chat m1) {
this.m = m1;
new Thread(this, "Question").start();
}

public void run() {
for (int i = 0; i < s1.length; i++) {
m.Question(s1[i]);	//Question方法被同步化了
m.sum++;	//该sum没有被同步化，sum值被共同修改
}
}
}

class T2 implements Runnable {
Chat m;
String[] s2 = { "Hi", "I am good, what about you?", "Great!" };

public T2(Chat m2) {
this.m = m2;
new Thread(this, "Answer").start();
}

public void run() {
for (int i = 0; i < s2.length; i++) {
m.Answer(s2[i]);
m.sum++;
}
}
}
public class ThreadCommunication {
public static void main(String[] args) {

Chat m = new Chat();
new T1(m);
new T2(m);
}
}

输出结果：

Question: sum = 0, Hi
Answer: sum = 1, Hi
Question: sum = 2, How are you ?
Answer: sum = 3, I am good, what about you?
Question: sum = 4, I am also doing fine!
Answer: sum = 5, Great!

3、线程死锁（deadlock）：描述某两个或多个线程被永远锁住，都在等待彼此线程。