Java多线程知识点总结

1、多线程创建方式

（1）继承Thread类

public class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

（2）实现Runnable接口

public class MyRunnbale implements Runnable{

    @Override
    public void run() {
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        MyRunnbale myRunnbale = new MyRunnbale();
        Thread thread = new Thread(myRunnbale);
        thread.start();
    }
}

（3）实现Callable接口

public class MyCallable implements Callable {

    @Override
    public String call() throws Exception {
        Thread.sleep(3000);
        return "hello world";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        FutureTask futureTask = new FutureTask(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
    }
}

Callable的call () 方法是有返回值的，运行Callable任务可以拿到一个Future对象，表示异步计算的结果。
FutureTask类同时实现了两个接口，Future和Runnable接口，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

调用start () 还是 run () 方法启动线程？

调用start () 方法才是真正的运行线程，调用run（）方法只是当作普通方法执行，程序还是要顺序执行。

Thread和Runnable的区别？

（1）由于Java不允许多继承，因此实现了Runnable接口可以再继承其他类，但是Thread不可以
（2）Runnable比Thread更适合共享同一个资源

2、线程的生命周期

调用start（）后，线程会被放到等待队列，等待CPU调度，并不一定要马上开始执行，只是将这个线程置于可动行状态。

阻塞的情况又分为：
（1）等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。
（2）同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
（3）其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

3、线程管理

（1）线程睡眠 —— sleep ()

sleep是静态方法，最好不要用Thread的实例对象调用它，因为它睡眠的始终是当前正在运行的线程，而不是调用它的线程对象，它只对正在运行状态的线程对象有效。

public static void main(String[] args) throws InterruptedException {
        System.out.println(Thread.currentThread().getName());
        MyThread myThread = new MyThread();
        myThread.start();
        Thread.sleep(1000); //这里休眠的不一定是myThread线程，而是当前运行的线程
        for (int i=0;i<100;i++){
            System.out.println("main:"+i);
        }
    }

（2）线程让步 —— yield ()

yield()方法和sleep()方法有点相似，它也是Thread类提供的一个静态的方法，它也可以让当前正在执行的线程暂停，让出cpu资源给其他的线程。但是和sleep()方法不同的是，它不会进入到阻塞状态，而是进入到就绪状态。yield()方法只是让当前线程暂停一下，重新进入就绪的线程池中，让系统的线程调度器重新调度器重新调度一次，完全可能出现这样的情况：当某个线程调用yield()方法之后，线程调度器又将其调度出来重新进入到运行状态执行。

public class Test01 {
    public static void main(String[] args) {
        new MyThread("低级", 1).start();
        new MyThread("中级", 5).start();
        new MyThread("高级", 10).start();
    }

    static class MyThread extends Thread {
        public MyThread(String name, int pro) {
            super(name);// 设置线程的名称
            this.setPriority(pro);// 设置优先级
        }

        @Override
        public void run() {
            for (int i = 0; i < 30; i++) {
                System.out.println(this.getName() + "线程第" + i + "次执行！");
                if (i % 5 == 0) {
                    Thread.yield();
                }
            }
        }
    }
}

（3）线程让步 —— join ()

join方法其实就是阻塞当前调用它的线程，等待join执行完毕，当前线程继续执行。

public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        MyThread threadA = new MyThread("A");
        MyThread threadB = new MyThread("B");
        threadA.start();
        threadA.join(); // 会阻塞main线程，使得下面一句必须等到threadA线程结束才能执行，所以A、B线程没有交替执行
        threadB.start();
    }

    static class MyThread extends Thread {
        public MyThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; ++i) {
                System.out.println(this.getName() + ": " + i);
            }
        }
    }
}

join源码中，只会调用wait方法，并没有在结束时调用notify，这是因为线程在die的时候会自动调用自身的notifyAll方法，来释放所有的资源和锁。

（4）设置线程的优先级

• 1）优先级高的线程可以获得较多的执行机会，而优先级低的线程则获得较少的执行机会。
• 2）每个线程默认的优先级都与创建它的父线程具有相同的优先级，在默认情况下，main线程具有普通优先级。
• 3）Thread类提供了setPriority(int newPriority)和getPriority()方法来设置和返回一个指定线程的优先级，其中setPriority方法的参数是一个整数，范围是1~10之间，也可以使用Thread类提供的三个静态常量：
  MAX_PRIORITY =10
  MIN_PRIORITY =1
  NORM_PRIORITY =5

public class Test01 {
    public static void main(String[] args) {
        MyThread threadA = new MyThread("A", Thread.MAX_PRIORITY);
        MyThread threadB = new MyThread("B", Thread.MIN_PRIORITY);
        threadA.start();
        threadB.start();
    }

    static class MyThread extends Thread {
        public MyThread(String name, int pro) {
            super(name); //设置线程名称
            setPriority(pro); // 设置线程优先级
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; ++i) {
                System.out.println(this.getName() + ": " + i);
            }
        }
    }
}

（5）守护线程

只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。

public class Test01 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.setDaemon(true); // 守护线程随着所有用户线程结束，跟随JVM一起结束
        myThread.start();
        System.out.println(Thread.currentThread().getName()+"停止运行");
    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            while (true){
                System.out.println("守护线程 正在运行!");
            }
        }
    }
}

（6）停止线程

1）使用标志位终止线程

public class Test01 {

    // volatile修饰符用来保证其它线程读取的总是该变量的最新的值
    public static volatile boolean interrupt = true;

    public static void main(String[] args) throws InterruptedException {

        MyThread myThread = new MyThread();
        myThread.start();
        Thread.sleep(1000);
        interrupt = false; //修改标志位，退出线程
        System.out.println(Thread.currentThread().getName() + "停止运行");
    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            while (interrupt) {
                System.out.println(Thread.currentThread().getName() + "：正在运行");
            }
        }
    }
}

2）使用interrupt()方法来终止线程
nterrupt()方法用于中断线程，调用该方法的线程状态将会被置为“中断状态”。
线程中断仅仅是置线程的中断状态位，不会停止线程。需要用户自己去监视线程的状态为并做处理。
调用这种方式去终止的线程存在两种情况：

• 第一种情况：该线程循环执行不会存在阻塞，这样的话调用interrupt()会立即终止该线程
• 第二种情况：该线程循环执行存在阻塞状态，比如，在线程中存在sleep()、await()、wait(long) 这种能够抛出：interruptedException 异常的方法，这种情况调用interrupt()方法后将会触发这些异常，可以选择在触发异常后调用break来终止线程

// 第一种情况
public class Test01 {

    public static void main(String[] args) throws InterruptedException {

        MyThread myThread = new MyThread();
        myThread.start();
        Thread.sleep(1000);
        myThread.interrupt();
        System.out.println(Thread.currentThread().getName() + "停止运行");
    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            while (!isInterrupted()) {
                System.out.println(Thread.currentThread().getName() + "：正在运行");
            }
        }
    }
}

//第二种情况
public class Test01 {

    public static void main(String[] args) throws InterruptedException {

        MyThread myThread = new MyThread();
        myThread.start();
        Thread.sleep(1000);
        myThread.interrupt();
        System.out.println(Thread.currentThread().getName() + "停止运行");
    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 100; ++i) {
                try {
                    Thread.sleep(100);
                    System.out.println(i);
                } catch (InterruptedException e) {
                    System.out.println(Thread.currentThread().getName()+"停止了");
                    break;
                }
            }
        }
    }
}

sleep()与wait()的区别？

（1）sleep是Thread的静态类方法，wait来自Object类
（2）sleep方法没有释放锁，而wait方法释放了锁
（3）wait，notify和notifyAll只能在同步方法或者同步代码块里面使用，而sleep可以在任何地方使用
（4）sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常