java多线程-初探（一）

啥是多线程？跟进程又是啥关系？

 

比方说：我去洗手，洗完手去吃饭。

进程(Processor)

洗手跟吃饭是两个进程。

线程(Thread)

在洗手的进程里，我同时听歌，还唱歌。那这里洗手是一个进程，听歌跟唱歌是两个线程。

在吃饭的进程里，我同时听歌，还唱歌。那这里吃饭是一个进程，听歌跟唱歌是两个线程。

吃饭跟洗手两个进程之间的线程互不干扰，同个进程之间的线程存在锁、等待、唤醒等等等机制。

 

多线程：同一个进程内做多件事，每件事是一个线程

创建线程有两种方式：继承Thread，实现Runnable接口

合理的使用多线程，可以提高程序的效率，如果无限制的开启多线程，会导致程序的效率降低。

多线程运行原理

任何程序运行都需要CPU执行。但是CPU在某个时间点上，它只能处理某一条指令。

但它可以在很短的时间内在多个线程（指令）之间高速的切换。导致我们误认为多个程序在同时运行。

 

这里创建一个普通java项目。

 

单线程示例

以吃饭为例，只有听完歌才能唱歌，无法边听边唱。

 

class Main

public class Main {

    /**
     * 吃饭
     * @param args
     */
    public static void main(String[] args) {
        Song song = new Song();
        while (!song.listenIsZero())
            song.doThing("listen") ;
        while (!song.singIsZero())
            song.doThing("sing") ;
        System.out.println("执行完成!");
    }
}

class Song

public class Song {

    // 待唱的歌曲数量
    private int singNum = 5 ;

    // 待听的歌曲数量
    private int listenNum = 5 ;

    public boolean singIsZero(){
        return singNum == 0 ;
    }

    public boolean listenIsZero(){
        return listenNum == 0 ;
    }

    public void doThing(String thing){
        switch (thing){
            case "sing" : doSing(); break;
            case "listen" : doListen(); break;
        }
    }

    public void doSing(){
        try {
            // 唱歌需要时间，加时间能体现多线程的效果
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("唱了一首歌，剩余：" + singNum-- +"首未唱");
        if (singIsZero()) System.out.println("唱完了！");
    }

    public void doListen(){
        try {
            // 听歌需要时间，加时间能体现多线程的效果
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("听了一首歌，剩余：" + listenNum-- +"首未听");
        if (listenIsZero()) System.out.println("听完了！");
    }

}

执行结果

 

多线程示例（继承Thread类）

可以在吃饭的进程里，边听歌边唱歌。同时进行。

创建一个类负责听歌或者唱歌，继承Thread，重写run函数。

建立两个线程，都start之后可以观察到两个线程同时调用doThing函数。

 

class Main

public class Main {

    /**
     * 吃饭
     * @param args
     */
    public static void main(String[] args) {
        // 单线程示例
        /*Song song = new Song();
        while (!song.listenIsZero())
            song.doThing("listen") ;
        while (!song.singIsZero())
            song.doThing("sing") ;*/

        // 多线程示例
        SongThread listen = new SongThread("listen", new Song());
        SongThread sing = new SongThread("sing", new Song());
        // 启动两个线程
        listen.start();
        sing.start();
        System.out.println("执行完成!");
    }
}

class SongThread

public class SongThread extends Thread{

    private Song song ;

    private String thing ;

    public SongThread(String thing, Song song){
        this.song = song;
        this.thing = thing;
    }

    public void run(){
        switch (thing){
            case "listen" : while (!song.listenIsZero()) song.doListen(); break;
            case "sing" : while (!song.singIsZero()) song.doSing(); break;
        }
    }

}

执行结果

 

为什么要继承Thread类？

线程本身是操作系统中存在的一个需要CPU去执行的任务（指令）。

而我们希望我们的代码可以被多个线程同时运行。

我们的代码就需要和线程产生关系，而在Java中负责和线程交互的类是Thread。

为什么要重写Run方法？

继承Thread是让我们的类和线程有关系，但是我们类中书写的代码需要最终被线程执行，这时书写的代码必须书写在线程可以运行的指令。

当有了线程对象之后，调用start方法，JVM会自动的调用当前线程中的run方法。这时我们需要把让线程执行的自己的代码书写在run方法中，线程开启之后，就会自动的把我们的代码也运行了。

开启线程的目的：让线程来运行我们自己指定的代码，而这些被线程运行的代码称为线程开启之后需要执行的任务。

为什么要调用start方法？

当我们创建了线程对象（Thread或Thread的子类），只有调用了start方法，才能在栈内存中划分出一个新的栈区来运行当前这个线程的任务。如果不调用start方法，仅仅是代表有了线程，但是线程并不会独立的去运行。

调用了start方法，在start方法中JVM会自动的调用run方法，run方法会被加载到当前新的栈区中运行，这样会导致栈内存中有主线程，还有我们调用start之后开启的新线程，这样cpu就会在多个线程之间进行切换。

 

多线程示例（实现Runnable接口）

创建一个类实现Runnable接口，然后new Thread的时候将实现类传参之后start。

Thread与Runnable的关系：Thread类实现了Runnable接口。

 

class Main

public class Main {

    /**
     * 吃饭
     * @param args
     */
    public static void main(String[] args) {
        // 单线程示例
        /*Song song = new Song();
        while (!song.listenIsZero())
            song.doThing("listen") ;
        while (!song.singIsZero())
            song.doThing("sing") ;*/

        /*// 多线程示例 Thread
        SongThread listen = new SongThread("listen", new Song());
        SongThread sing = new SongThread("sing", new Song());
        // 启动两个线程
        listen.start();
        sing.start();
        System.out.println("执行完成!");*/

        // 多线程示例 实现Runnable接口
        SongRunnable listen = new SongRunnable("listen", new Song());
        SongRunnable sing = new SongRunnable("sing", new Song());
        // 启动两个线程
        new Thread(listen).start();
        new Thread(sing).start();
    }
}

 

class SongRunnable

public class SongRunnable implements Runnable{

    private Song song ;

    private String thing ;

    public SongRunnable(String thing, Song song){
        this.song = song;
        this.thing = thing;
    }

    public void run(){
        switch (thing){
            case "listen" : while (!song.listenIsZero()) song.doListen(); break;
            case "sing" : while (!song.singIsZero()) song.doSing(); break;
        }
    }

}

 

执行结果

 

Thread跟Runnable到底更推荐用哪个？

实现上的区别：Thread需要类继承。Runnable需要类实现该接口。

所以话题就转到了：继承跟实现都可以实现的功能，选继承还是实现？

继承的局限性：

在Java中每个类的直接父类只能有一个，不能多继承。

而JDK中提供的Thread方式，让某个类需要去继承Thread，才能创建线程并开启线程。

当一个类继承了Thread，就无法再去继承其他的类。

首先一个类它应该有自己所属的体系。如果一个子类中需要有多线程执行的代码，采用继承的方式会导致这个子类脱离原有的继承体系。然后去继承Thread，这种方式肯定不可取。

接口的好处：

一个类可以去继承某个父类的同时，还能实现多个接口。

实现了Runnable接口的实现类本身与线程（Thread）并无关系，无法直接开启线程。

当需要启动线程时，将Runnable实现类交给Thread对象，这样就有线程关系了，start启动。

 

java多线程-初探（二）

 

实际业务应用场景举例

1.后台需要定时给数据库100w个用户发送提醒邮件。

 启动两个线程分别给50w个用户发邮件。

2.不影响用户情况下记录用户操作日志（异步）

 启动一个线程去单独执行记录日志的操作。