1、线程与进程区别

A、每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。线程是一组
   指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代
   码运行的上下文。所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。
   通常由操作系统负责多个线程的调度和执行。
B、使用线程可以把占据时间长的程序中的任务放到后台去处理，程序的运行速度可能加
   快，在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较
   有用了。在这种情况下可以释放一些珍贵的资源如内存占用等等。
C、如果有大量的线程,会影响性能，因为操作系统需要在它们之间切换，更多的线程需
   要更多的内存空间，线程的中止需要考虑其对程序运行的影响。通常块模型数据是
   在多个线程间共享的，需要防止线程死锁情况的发生。

总结:进程是所有线程的集合，每一个线程是进程中的一条执行路径。

2、多线程应用场景

    主要能体现到多线程提高程序效率。
    举例: 迅雷多线程下载、分批发送短信等。

3、多线程的创建方式

3.1、继承Thread类，重写run方法

    package com.kid.neo;
    class CreateThreadDemo01 extends Thread{
        //run方法就是线程需要执行的任务或者执行的代码
        @Override
        public void run() {
            for (int i = 0; i < 30; i++) {
                System.out.println("run,i:"+i);
            }
        }
    }
    
    //如何创建多线程:继承Thread类重写run方法 
    public class ThreadDemo01 {
        
        /**
         * 什么是进程， 进程就是正在运行的应用程序，进程是线程的集合。 
         * 什么是线程，线程就是一条执行路径，一个独立的执行单元。 
         * 什么是多线程，为了提高程序效率 创建有哪些方式？ 
         * 1、使用继承Therad类方式 继承Thread类重写run方法 
         * 2、使用实现runlabe接口方式
         * 3、使用匿名内部类方式 
         * 4、callable 
         * 5、使用线程池创建线程。
         */
        public static void main(String[] args) {
            //调用线程
            CreateThreadDemo01 t1=new CreateThreadDemo01();
            // 启动线程 不是调用run方法，而是调用start方法。
            // run的话会依次执行，先执行子线程再执行主线程
            // 使用开启多线程后，代码不会从上往下进行执行。
            //t1.run();
            t1.start();
            for (int i = 0; i < 30; i++) {
                System.out.println("main,i:"+i);
            }
        }
    }

3.2、实现runlabe接口方式，重写run方法

    package com.kid.neo;
    class CreateThreadDemo02 implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 30; i++) {
                System.out.println("子线程run,i:"+i);
            }
        }
    }
    
    //使用实现runlabe接口方式
    public class ThreadDemo02 {
    
        public static void main(String[] args) {
            CreateThreadDemo02 t2 = new CreateThreadDemo02();
            Thread thread=new Thread(t2);
            thread.start();
            for (int i = 0; i < 30; i++) {
                System.out.println("主线程 i:" + i);
            }
        }
    }

使用继承Thread类还是使用实现Runnable接口好？

    使用实现实现Runnable接口好，原因实现了接口还可以继续继承，继承了类不能再继承。

启动线程是使用调用start方法还是run方法？

    开始执行线程，注意：开启线程不是调用run方法，而是start方法
    调用run只是使用实例调用方法。

获取线程对象以及名称

    常用线程api方法
        start() 启动线程
        currentThread() 获取当前线程对象
        getID() 获取当前线程ID      Thread-编号  该编号从0开始
        getName()   获取当前线程名称
        sleep(long mill)    休眠线程
        Stop（）  停止线程,
    常用线程构造函数
        Thread（）    分配一个新的 Thread 对象
        Thread（String name） 分配一个新的 Thread对象，具有指定的 name正如其名。
        Thread（Runable r）   分配一个新的 Thread对象
        Thread（Runable r, String name）  分配一个新的 Thread对象

3.3、使用匿名内部类方式

    package com.kid.neo;
    abstract class Parent{
        public abstract void add();
    }
    
    //使用匿名内部类方式 
    public class ThreadDemo03 {
        public static void main(String[] args) {
            
            /**
             * 什麼是匿名 +內部类
             *  Parent parent = new Parent() {
             *  @Override
             *  public void add() {
             *      System.out.println("使用自定义内部类");
             *      }
             *  };
             *  parent.add();
             */
            
            Thread t1=new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 30; i++) {
                        System.out.println("子线程，i:"+i);
                    }
                }
            });
            t1.start();
            for (int i = 0; i < 30; i++) {
                System.out.println("主线程，i:"+i);
            }
        }
    }

4、多线程运行状态

    线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。

4.1、新建状态

    当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。
    当一个线程处于新生状态时，程序还没有开始运行线程中的代码

4.2、就绪状态

    一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()
    方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返
    回后，线程就处于就绪状态。
    处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间
    才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行
    状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度
    程序(thread scheduler)来调度的。

4.3、运行状态

    当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.

4.4、阻塞状态

    线程运行过程中，可能由于各种原因进入阻塞状态:
        A、线程通过调用sleep方法进入睡眠状态；
        B、线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
        C、线程试图得到一个锁，而该锁正被其他线程持有；
        D、线程在等待某个触发条件；

4.5、死亡状态

    有两个原因会导致线程死亡：
        A、run方法正常退出而自然死亡，
        B、一个未捕获的异常终止了run方法而使线程猝死。
        为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。
        如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程
        死亡了，则返回false。

5、join()方法作用

    join作用是让其他线程变为等待,   t1.join()；// 让其他线程变为等待，直到当前t1线程执行完毕，才释放。
    thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B
    中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。

5.1、演示Demo:创建一个线程，子线程执行完毕后，主线程才能执行。

    class JoinThread implements Runnable {
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "---i:" + i);
            }
        }
    }
    
    public class JoinThreadDemo {
    
        public static void main(String[] args) {
            JoinThread joinThread = new JoinThread();
            Thread t1 = new Thread(joinThread);
            Thread t2 = new Thread(joinThread);
            t1.start();
            t2.start();
            try {
           //其他线程变为等待状态，等t1线程执行完成之后才能执行join方法。
                t1.join();
            } catch (Exception e) {
    
            }
            for (int i = 0; i < 100; i++) {
                System.out.println("main ---i:" + i);
            }
        }
    }

5.2、优先级

    现代操作系统基本采用时分的形式调度运行的线程，线程分配得到的时间片的多少决定了线程使用处理器资源的
    多少，也对应了线程优先级这个概念。在JAVA线程中，通过一个int priority来控制优先级，范围为1-10，
    其中10最高，默认值为5。下面是源码（基于1.8）中关于priority的一些量和方法。

    class PrioritytThread implements Runnable {
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().toString() + "---i:" + i);
            }
        }
    }
    
    public class ThreadDemo4 {
    
        public static void main(String[] args) {
            PrioritytThread prioritytThread = new PrioritytThread();
            Thread t1 = new Thread(prioritytThread);
            Thread t2 = new Thread(prioritytThread);
            t1.start();
            // 注意设置了优先级， 不代表每次都一定会被执行。 只是CPU调度会有限分配
            t1.setPriority(10);
            t2.start();
        }
    }

5.3、Yield方法

    Thread.yield()方法的作用：暂停当前正在执行的线程，并执行其他线程。（可能没有效果）
    yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。
    因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。但是，实际中无法
    保证yield()达到让步的目的，因为，让步的线程可能被线程调度程序再次选中。
    结论：大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

6、多线程分批处理数据（演示代码案例）

    需求:目前有10万个用户，现在需要做活动，给每一个用户发送一条祝福短信。
        为了提高数程序的效率，请使用多线程技术分批发送据。
        每开一个线程，都会占用CPU资源
        服务器（电脑）配置 CPU 核数
    
    //创建线程
    class UserSendThread implements Runnable{
        private List<User> listUser;
        public UserSendThread(List<User> listUser) {
            this.listUser=listUser;
        }
        
        @Override
        public void run() {
            for (User user : listUser) {
                System.out.println(Thread.currentThread().getName()+","+user.toString());
            }
            System.out.println();
        }
    }
    
    //实现发送短信
    public class BatchSms {
    
        public static void main(String[] args) {
            // 1.初始化数据
            List<User> initUser = initUser();
            // 2.定义每个线程分批发送大小
            int userCount=2;
            // 3.计算每个线需要分配跑的数据
            List<List<User>> splitList = ListUtils.splitList(initUser, userCount);
            for (int i = 0; i < splitList.size(); i++) {
                List<User> list = splitList.get(i);
                UserSendThread userSendThread=new UserSendThread(list);
                // 4.分配发送
                Thread thread = new Thread(userSendThread,"线程"+i);
                thread.start();     
            }   
        }
    
        //模拟数据
        static private List<User> initUser() {
            List<User> list = new ArrayList<User>();
            for (int i = 1; i <= 11; i++) {
                list.add(new User("userId:" + i, "userName:" + i));
            }
            return list;
        }
    }

总结：小项目可以这样实现，大项目不行;要考虑数量，线程池管理,使用消息中间件，保证数据的一致性

7、现在有T1、T2、T3三个线程，如何保证T2在T1执行完后执行，T3在T2执行完后执行？

    public class JoinDemo {
        public static void main(String[] args) {
            Thread t1 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 20; i++) {
                        System.out.println("t1,i:" + i);
                    }
                }
            });
            Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        t1.join();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    for (int i = 0; i < 20; i++) {
                        System.out.println("t2,i:" + i);
                    }
                }
            });
            Thread t3 = new Thread(new Runnable() {
                public void run() {
                    try {
                        t2.join();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    for (int i = 0; i < 20; i++) {
                        System.out.println("t3,i:" + i);
                    }
                }
            });
            t1.start();
            t2.start();
            t3.start();
        }
    }