线程开启的三种方式

什么是进程?
正在执行的程序

什么是线程?
具有完成独立任务的一条执行路径

什么是多进程?
多个应用程序的集合

什么是多线程?
一个进程可以有一条线程，一个进程也可以有多条线程

多进程的好处?
能够合理的提高CPU的使用率 提高CPU的使用率

多线程的好处?
提高了进程和CPU的使用率

为什么需要开启多线程?什么时候开启线程?
1.能够让多个进程看上去像同时执行
2.防止单线程出现线程阻塞
3.用于处理耗时操作
场景：访问数据库 访问网络 更新界面。。。

其实多线程本质CPU还是按照顺序流来处理，只不过CPU的执行速度太快了，我们肉眼察觉不到，所以看起来像同时执行

线程的开启的三种方式

1. 继承Thread类

/**
 * @author ZSL
 * @ClassName MyThread
 * @description
 * 第一种开启线程的方式
 * 继承Thread类，新建一个当前类对象，并且运行其start()方法
 * @date 2019/8/18
 */
public class MyThread extends Thread {

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }
    // Thread.currentThread()表示当前正在执行的是哪一条线程那么就是对应的那个线程的名称
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }


}

测试

/**
 * @author ZSL
 * @ClassName MyThreadTest
 * @description
 * @date 2019/8/18
 */
public class MyThreadTest {

    public static void main(String[] args) {
        MyThread my1 = new MyThread("线程1");
        MyThread my2 = new MyThread("线程2");


        // 开启线程
        my1.start();
        my2.start();

    }
}

结果

2. 实现Runnable接口

/**
 * @author ZSL
 * @ClassName Demo2_Thread
 * @description
 * 第二种开启线程的方式
 * 实现Runnable接口，然后新建当前类对象，
 * 接着新建Thread对象时把当前类对象传进去，
 * 最后运行Thread对象的start()方法
 *
 * @date 2019/8/18
 */
public class Demo2_Thread implements Runnable{

    private String str;

    public Demo2_Thread(String str) {
        this.str = str;
    }

    public Demo2_Thread() {
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(i + str + " run()...");
        }
    }
}

测试

/**
 * @author ZSL
 * @ClassName MyThreadTest
 * @description
 * @date 2019/8/18
 */
public class MyThreadTest {

    public static void main(String[] args) {
        new Thread(new Demo2_Thread("线程1")).start();
        new Thread(new Demo2_Thread("线程2")).start();
    }
}

结果

3. 实现Callable接口

/**
 * @author ZSL
 * @ClassName Demo3_Thread
 * @description
 * 第三种开启线程的方式
 *
 * 实现Callable接口，新建当前类对象，
 * 在新建FutureTask类对象时传入当前类对象，
 * 接着新建Thread类对象时传入FutureTask类对象，
 * 最后运行Thread对象的start()方法
 * @date 2019/8/18
 */
public class Demo3_Thread implements Callable {

   private String string;

    public Demo3_Thread(String string) {
        this.string = string;
    }

    public Demo3_Thread() {
    }

    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 1000; i++) {
            System.out.println(i + string +" call()...");
        }
        return null;
    }
}

测试

/**
 * @author ZSL
 * @ClassName MyThreadTest
 * @description
 *
 * @date 2019/8/18
 */
public class MyThreadTest {

    public static void main(String[] args) {
        Callable callable1 = new Demo3_Thread("线程1");
        Callable callable2 = new Demo3_Thread("线程2");

        FutureTask futureTask1 = new FutureTask(callable1);
        FutureTask futureTask2 = new FutureTask(callable2);

        Thread thread1 = new Thread(futureTask1);
        Thread thread2 = new Thread(futureTask2);

        thread1.start();
        thread2.start();
    }
}

结果