一、程序

例如QQ、微信等这样的利用，即是程序。

二、过程

过程就是一个程序运行起来的状态。

三、线程

线程是一个过程中不同的执行门路。

业余一点的解释：
过程是OS分配资源的根本单位，线程是执行调度的根本单位。分配资源最重要的是：开拓独立的内存空间，线程再调度执行（即线程共享过程的内存空间，没有本人独立的内存空间）

四、纤程/协程

纤程是用户态的线程，线程中的线程；纤程的切换和调度不须要通过内核，而线程的切换是在内核态实现的。

1、与线程相比，纤程特点

1）占有资源少，个别OS的线程占用1M，纤程4K

2）切换比较简单

五、创立线程的办法

1、继承Thread类

2、实现Runnable接口

3、通过Executor线程池创立

/**
 * @author Java和算法学习：周一
 */
public class CreateThread {

    private static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("MyThread");
        }
    }

    private static class MyRun implements Runnable {
        @Override
        public void run() {
            System.out.println("MyRun");
        }
    }

    public static void main(String[] args) {
        new MyThread().start();
        new Thread(new MyRun()).start();

        new Thread(()->{
            System.out.println("lambda...");
        }).start();
    }

}

六、线程罕用的办法

1、Sleep办法

让出以后执行的线程，给别的线程去运行

2、Yield办法

谦让的退出一下，即让出CPU一下；此线程会到线程的期待队列里，CPU有可能会再次执行该线程，但更大的可能是执行其余的线程。

3、Join办法

进行执行以后的线程，转而去执行join的线程

/**
 * @author Java和算法学习：周一
 */
public class SleepYieldJoin {

    public static void main(String[] args) {
//        testSleep();
//        testYield();
        testJoin();
    }

    static void testSleep() {
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("SleepA" + i);
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("SleepB" + i);
            }
        }).start();
    }

    static void testYield() {
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("yieldA" + i);
                if (i % 2 == 0) {
                    Thread.yield();
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("yieldB" + i);
                if (i % 2 == 0) {
                    Thread.yield();
                }
            }
        }).start();
    }

    static void testJoin() {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("A" + i);
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            for (int i = 0; i < 10; i++) {
                System.out.println("B" + i);
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t3 = new Thread(() -> {
            try {
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            for (int i = 0; i < 10; i++) {
                System.out.println("c" + i);
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        //不论t1、t2、t3启动程序怎么，输入后果都一样，这就能够保障t1、t2、t3按程序执行
        t3.start();
        t2.start();
        t1.start();
    }

}