4个小例子看java线程挂起方法

本文代码都可在eclipse上直接运行

1.首先看个最简单的方法，也是你最容易理解的：suspend。（注意：已经废弃了，说是会导致死锁）

public class Thread1{
    public static void main(String[] args) {
    ThreadC c = new ThreadC();
        c.start();
    }
}
class ThreadC extends Thread{
public void run() {
        ThreadB b = new ThreadB();
        b.start();
    System.out.println("c等待1开始");
    try {
sleep(2000);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
    System.out.println("c等待1完成");
    try {
    b.suspend();
    System.out.println("b.suspend()");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
        System.out.println("c等待2开始");
        try {
    sleep(2000);
    } catch (InterruptedException e1) {
    // TODO Auto-generated catch block
    e1.printStackTrace();
    }
       
        System.out.println("c等待2完成");
        b.resume();
        System.out.println("c说：b对象计算的总和是：" + b.total);
}}
class ThreadB extends Thread {
    int total;
    public void run() {
            for (int i = 0; i < 10; i++) {
                total += i;
                System.out.println("b说： 我查数"+i);
                try {
sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
            }
    }
}

2.再看另一个使用join的方法：

public class Thread1{
    public static void main(String[] args) {
    ThreadC c = new ThreadC();
        c.start();
    }
}
class ThreadC extends Thread{
public void run() {
        ThreadB b = new ThreadB();
        
    System.out.println("c等待1开始");
    try {
sleep(2000);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
    System.out.println("c等待1完成");
    try {
    b.start();
b.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
        System.out.println("c等待2开始");
        try {
    sleep(2000);
    } catch (InterruptedException e1) {
    // TODO Auto-generated catch block
    e1.printStackTrace();
    }
       
        System.out.println("c等待2完成");
        
        System.out.println("b对象计算的总和是：" + b.total);
}}


class ThreadB extends Thread {
    int total;
    public void run() {
            for (int i = 0; i < 10; i++) {
                total += i;
                System.out.println("我是b 我查数"+i);
                try {
sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
            }
           
    }
}

3.现在学习wait和notify的使用，这需要配合synchronized 的使用。

让我们看看wait和notify是怎么释放和还回锁的：

public class Thread1{
    public static void main(String[] args) {
    ThreadC c = new ThreadC();
        c.start();
    }
}
class ThreadC extends Thread{
public void run() {
        ThreadB b = new ThreadB();
        Object theO=new Object();
        b.setO(theO);
        // 启动计算线程
        b.start();
        
    synchronized (theO) {//给这个代码块加锁
            try {
    System.out.println("c等待开始");
    try {
sleep(1000);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
    System.out.println("c等待完成");
                
    theO.wait();// 释放这个锁给另一个锁定的块，让另一个块执行
               
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("b对象计算的总和是：" + b.total);
        }
    }
}


class ThreadB extends Thread {
    int total;
    Object o;
    public void setO(Object o)
    {
    this.o=o;
    }
    public void run() {
        synchronized (o) {//我是另一个块，我开始不会执行，因为ThreadC里的锁定块先抢到了锁
            for (int i = 0; i < 10; i++) {
                total += i;
                System.out.println("我是b 我查数"+i);
                try {
sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
            }
           
            o.notify();//释放这个锁，给ThreadC继续执行
        }
    }
}

4.最后写一个使用wait和notify进行线程挂起的例子：

public class Thread1{
    public static void main(String[] args) {
    ThreadC c = new ThreadC();
        c.start();
    }
}
class ThreadC extends Thread{
public void run() {
        ThreadB b = new ThreadB();
        Object theO=new Object();
        b.setO(theO);
        b.start();
        try {
        System.out.println("c开始等500毫秒");
sleep(500);

} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
    synchronized (theO) {
    try{
    for (int i = 0; i < 6; i++) {
    System.out.println("c查数： "+i);
    sleep(500);
}
    System.out.println("c notify这个对象，还锁");
    theO.notify();
   
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


class ThreadB extends Thread {
    int total;
    Object o;
    public void setO(Object o)
    {
    this.o=o;
    }
    public void run() {
        synchronized (o) {
            for (int i = 0; i < 10; i++) {
                total += i;
                System.out.println("b 我查数"+i);
                if(i==5)
try {
System.out.println("b wait 释放这个锁");
o.wait();

} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
                try {
sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
            }
        }
    }
}