[从零开启 Java 多线程 - 1 ]：开胃小菜

前言

这是一个关于多线程的系列文章。在接下来的一段时间里，文章将围绕多线程进行从浅入深的连载，感兴趣的朋友可以关注一下~

正文

小A：咱们聊完了概念性的东西，是不是要聊一聊实际的用法啦？

MDove：OK，接下来我们正式进入多线程的世界。今天我们聊一聊基本的使用和一些面试常客的方法。下一篇则重点谈一谈锁。

MDove：我们都知道，在Java中开启多线程。有两种手段：一种是继续Thread类；另外一种是实现Runable接口。（当然还可以实现Callable、Future等方式。）

小A：那继承Thread和实现Runable有什么不同么？

MDove：从技术角度上来说并没有不同，最大的不同应该算是设计上。因为我们都知道Java是单继承，所以当你继承了Thread势必不能继承其他类。因此implement接口可以实现“多继承”的效果。

小A：那这俩种方式是怎样写的呢？

MDove：

1.继承 Thread 类

public class MyThread extends Thread {
    @Override
    public void run() {
        //TODO
    }
}

public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();
}
复制代码

2.实现 Runnable 接口

public static void main(String[] args) throws InterruptedException {
    new Thread(new Runnable() {
        @Override
        public void run() {
            //TODO
        }
    }).start();
}
复制代码

MDove：调用start()就标志着线程的开启，但是start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。

MDove：另外需要注意一点，start()不应该被重复调用，否则会出现java.lang.IllegalThreadStateException异常。

小A：start线程我会了？那停止线程呢？是stop么？

停止线程

MDove：的确有stop()这个方法，不过已经不推荐使用了。比较正确的停止线程的几种方法是：

1、使用退出标志，使线程正常退出，也就是当run()方法完成后线程停止。

2、使用interrupt()方法中断线程。

MDove：简单写一个思路2的demo，你应该能够看明白：

public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            for (int i=0; i<50000; i++){
                if (this.isInterrupted()) {
                    System.out.println("已经是停止状态了！");
                    throw new InterruptedException();
                }
                System.out.println(i);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread =new MyThread();
        myThread.start();
        Thread.sleep(100);
        myThread.interrupt();
    }
}
复制代码

小A：通过Thread的interrupt()方法，来通知线程停止。然后我们通过isInterrupted()判断是否停止线程，然后使用抛异常的方式停止线程？

MDove：没错，但是不止抛异常，return，break都可以满足这个要求。

小A：OK，停止线程我明白了，我记得上篇文章，你用了大量的篇幅去聊线程安全的问题，那么在代码中，我们应该怎么做呢？

线程安全

MDove：OK，让我们先模拟一个简单的不安全的线程demo：

public class MyThread implements Runnable {
    private int count = 5;

    @Override
    public void run() {
        fun();
    }

    private void fun() {
        count--;
        System.out.println("线程:" + Thread.currentThread().getName() + "开始计算，计算结果count = " + count);
    }
}
复制代码

public static void main(String[] args) {
    MyThread myThread = new MyThread();
    Thread thread1 = new Thread(myThread,"线程1");
    Thread thread2 = new Thread(myThread,"线程2");
    Thread thread3 = new Thread(myThread,"线程3");
    Thread thread4 = new Thread(myThread,"线程4");
    Thread thread5 = new Thread(myThread,"线程5");
    thread1.start();
    thread2.start();
    thread3.start();
    thread4.start();
    thread5.start();
}
复制代码

MDove：结果不需多言，我相信有了上次文章的铺垫，这个demo的问题你也能看出来吧？

小A：是结果有重复么？没办法顺序的执行到0？

MDove：没错，这里出现的问题就是原子性的问题。因为自加或者是自减操作，真正成为指令时并非一个指令，而是3部：

• 1、取值
• 2、计算
• 3、赋值

MDove：因此，在这三个步骤中，如果有多个线程同时访问，那么一定会出现非线程安全问题。

小A：那如何解决这个问题呢？

MDove：最直接也是最简单的方法，使用synchronized同步关键字：

private synchronized void fun() {
    count--;
    System.out.println("线程:" + Thread.currentThread().getName() + "开始计算，计算结果count = " + count);
}
复制代码

打印结果： 线程2 计算 count = 4 线程3 计算 count = 3 线程1 计算 count = 2 线程4 计算 count = 1 线程5 计算 count = 0

MDove：当然我们也可以使用Lock：

ReentrantLock lock=new ReentrantLock();

private void fun() {
	lock.lock();
	try {
		count--;
		System.out.print("线程:" + Thread.currentThread().getName() + "开始计算，计算结果count = " + count);
	} finally {
		lock.unlock();
	}
}
复制代码

小A：那这俩者有什么不同呢？

MDove：不要着急，下一篇文章。再让我从字节码层面，好好得给你捋一捋它们的不同。当然这个题目还有其他的解法，比如volatile、AtomicInteger等手段保证可见性、原子性、有序性。

小A：volatile、AtomicInteger又是啥？

MDove：不要着急，接下来文章会好好针对volatile进行总结，毕竟是面试的常客。当然AtomicInteger也颇为重要，因为它是CAS思想的具体实现....

面试常客API

MDove：接下来，我们聊一聊一些基础的api的作用： ####sleep() 方法： sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。（不释放锁）

suspend() 和 resume() 方法：

suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形。

Thread 类中的方法；不会释放锁；可在任何位置调用。

yield() 方法：

yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。

wait() 和 notify() 方法（）：

两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。

Object中的方法； 会释放锁；这一对方法却必须在 synchronized 方法或块中调用。原因也很好理解：只有在synchronized这类同步代码块中，当前线程才占有锁，才有锁可以释放。同理，调用方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在synchronized这样的同步代码中。注意：若不满足这一条件，仍能编译，但在运行时会出现IllegalMonitorStateException异常。

interrupt()：

不要以为它是中断某个线程！它只是线线程发送一个中断信号，让线程在无限等待时（如死锁时）能抛出抛出，从而结束线程，但是如果你吃掉了这个异常，那么这个线程还是不会中断的！

MDove：这些方法可需要好好的去体会呦。不光是面试中常常遇到，更多是它们是我们操作Thread的利器。

小A：感觉线程还可以，不是很难。

MDove：那是因为我们目前才是最简单的使用阶段。如何高效、安全的使用线程，可不是只会使用api就够，既然synchronized可以满足线程安全，那么为什么还需要其他花里胡哨的各种各样的其他同步方式。所以多线程编程需要长久的经验支撑。咱们接下来的内容会一点点深入，希望你可以一直觉得不难呦~~

小A：嘿嘿嘿，迫不及待了~

剧终

我是一个应届生，最近和朋友们维护了一个公众号，内容是我们在从应届生过渡到开发这一路所踩过的坑，以及我们一步步学习的记录，如果感兴趣的朋友可以关注一下，一同加油~