[从零开启 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()这个方法，不过已经不推荐使用了。比较正确的中止线程的几种方法是：

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

二、使用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部：

• 一、取值
• 二、计算
• 三、赋值

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：嘿嘿嘿，火烧眉毛了~

剧终

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