6-java多线程的基本方法

sleep()

sleep是一个静态的本地方法，主要作用是使这个线程休眠一定时间，sleep的方法声明是这样的：

public static native void sleep(long millis) throws InterruptedException;

在使用的时候我们可以采取这样的方式。

try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

方法中的参数1000代表的是休眠1秒，这个方法可以让我们很明显的观察多线程的变化。比如之前的代码可以改成：

public class Main {
    public static void main(String[] args){
        Thread thread1=new Thread(new TheThread());
        Thread thread2=new Thread(new TheThread());
        Thread thread3=new Thread(new TheThread());
        thread1.start();
        thread2.start();
        thread3.start();
        System.out.println("Main");
    }
}
class TheThread implements Runnable{
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getId() + ":" + i);
        }
    }
}

获取线程的名字和id

在之前的例子中我们看到了一些方法可以获得线程的名字的方法，构造方法中也出现了给线程命名的方法。我们举个例子。

public class Main {
    public static void main(String[] args){
        Thread thread1=new Thread(new TheThread(),"thread1");
        Thread thread2=new Thread(new TheThread(),"thread2");
        Thread thread3=new Thread(new TheThread(),"thread3");
        thread1.start();
        thread2.start();
        thread3.start();
        System.out.println("Main");
    }
}
class TheThread implements Runnable{
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

通过getName方法可以获得名字，getId方法可以获得id

想停止线程？千万不要用stop()

在一定时候我们如果想停止线程怎么办？JDK中提供了stop方法，但是现在已经不建议使用了。

thread.stop();

这个方法会使线程突然停止，没有经过别的处理，所以在有的时候会造成脏读。在一些情况下，我们需要采取其他方式来停止线程。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1=new Thread(new TheThread(),"thread1");
        thread1.start();
        Thread.sleep(2);
        thread1.interrupt(); 
    }
}

在有时候，我们需要使用中断，但是中断并没有停止进程，我们需要改进这方式。
我们采用异常来停止线程

public class Main {
    public static void main(String[] args) throws InterruptedException {
        try{
            Thread thread1=new Thread(new TheThread(),"thread1");
            thread1.start();
            Thread.sleep(2);
            thread1.interrupt();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
class TheThread extends Thread{
    public void run() {
        super.run();
        for (int i = 0; i < 100; i++) {
            if(this.interrupted()){
                break;
            }
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

让线程交流一下，等待和通知

为了支持多线程之间的合作，JDK提供了两个非常重要的接口：线程等待（wait()）和通知（notify()），这两个方法的签名如下：

public final void wait() throws InterruptedException
public final native void notify()

这两个方法是final修饰的，不能被重写，而且notify是本地方法。当一个对象的实例调用了wait之后，当前线程就会在这个对象上等待，直到其他线程中有调用了notify方法的时候。Object中也有类似的方法，但是不能随便调用的。下面给大家一个实例说明这两个方法的用法。

public class Main {
    final static Object object=new Object();
    public static class T1 extends Thread{
        public void run(){
            synchronized (object){
                System.out.println(System.currentTimeMillis()+"T1 start");
                try {
                    System.out.println(System.currentTimeMillis()+"T1 waite");
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis()+"T1 end");
            }
        }
    }
    public static class T2 extends Thread{
        public void run(){
            synchronized (object){
                System.out.println(System.currentTimeMillis()+"T2 start");
                object.notify();
                System.out.println(System.currentTimeMillis()+"T2 end");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args){
        Thread thread1=new T1();
        Thread thread2=new T2();
        thread1.start();
        thread2.start();
    }
}