1. 多线程

程序：指令集，静态的概念

进程：操作系统调动程序，是程序的一次动态执行过程，动态的概念

线程：在进程内的多条执行路径

Ps：单核的话进程都是虚拟模拟出来的，多核处理器才可以执行真正的多线程

单核通过CPU调度时间片实现虚拟模拟的多线程，比如执行main函数和GC在底层就是多线程，你执行你的，我执行我的

一个进程内部的线程共享相同的内存单元，可以访问相同的变量和对象，所以存在并发控制问题

线程和进程的区别：

1. 根本区别：进程是资源分配的单位，而线程是调度和执行的单位

2. 所处环境：多进程是指操作系统中可以有多个进程，多线程是同一个进程中有多个顺序流同时执行

3. 切换开销：每个进程拥有自己独立的代码和数据空间（进程上下文），进程切换开销大，同一个进程内的线程因为是共享的进程的共享数据，所以线程切换的开销很小

4. 分配内存：系统会为每个进程分配不同的内存区域，而却不会为线程分配，线程使用的是进程的资源

多线程的实现方法：

方法1：继承Thread类

Rabbit.java

package 多线程;/** * @author:yb * @version 创建时间：2018-12-24 下午4:14:16 类说明 *//* * 模拟龟兔赛跑  * 1.创建多线程：继承Thread+重写run()线程体 * 2.使用线程：创建子类对象+对象调用start() */public class Rabbit extends Thread {    // 线程体    public void run() {        for (int i = 1; i <= 100; i++) {            System.out.println("兔子跑了" + i + "步");        }    }}class Tortoise extends Thread {    // 线程体    public void run() {        for (int i = 1; i <= 100; i++) {            System.out.println("乌龟跑了" + i + "步");        }    }}

RabbitApp.java

package 多线程;/** * @author:yb * @version 创建时间：2018-12-24 下午4:20:53 类说明 */public class RabbitApp {    public static void main(String[] args) {        // 创建子类对象        Rabbit rab = new Rabbit();        Tortoise tor = new Tortoise();        // 调用start方法，不用调用run方法这个线程体        rab.start();        tor.start();                /*         * 为什么输出会是兔子跑了两步乌龟才开始跑呢？         * 因为是虚拟模拟实现的多线程，在底层cpu的按照时间片的轮转调度的，时间片先是给兔子这个对象         * 它先跑两部，然后时间片时间到了，cpu把时间片给乌龟，然后乌龟开始跑         * 实现的是虚拟的多线程（CPU轮流调度）         * 如果是多核计算机的话，那才是真正的多线程2         */    }}

分析直接继承Thread类这种方法的优缺点：

缺点：因为java的单继承，多实现，当我们一开始继承了其他类的时候，就不能继承Thread类了

优点：好像没有什么优点

为了避免这一情况，我们通过Runnable接口实现多线程

所以我们有了方法2：通过Runnable接口实现多线程

 

方法2：通过Runnable接口实现多线程

在这里使用了一种设计模式：静态代理，关于静态代理可以参考我的这篇博客：

Programmer.java:

package 多线程;/** * @author:yb * @version 创建时间：2018-12-25 下午7:05:34 类说明 *//* * 使用Runnabke创建线程 *  1.类要实现Runnable接口+重写run方法体 -->真实角色 *  2.创建多线程 使用静态代理的设计模式  *    1）创建真实角色 *    2）创建代理角色+对真实角色的引用  *    3）调用start启动线程 */public class Programmer implements Runnable {    // 重写run方法体    public void run() {        for (int i = 0; i < 1000; i++) {            System.out.println("第" + i + "次敲Hello world");        }    }}

programmerApp.java:

package 多线程;/** * @author:yb * @version 创建时间：2018-12-25 下午7:05:52 类说明 */public class ProgrammerApp {    public static void main(String[] args) {        // 1）创建真实角色        Programmer pro = new Programmer();        // 2）创建代理角色+对真实角色的引用        Thread proxy = new Thread(pro);        // 3）调用start启动线程        proxy.start();        // 另外一个线程，因为main函数也算是一个线程        for (int i = 0; i < 1000; i++) {            System.out.println("第" + i + "次打开wegame");        }    }}

优点：

1.避免了单继承

2.方便共享资源，同一份资源，多个代理访问

 

共享资源的体现：（即同一个真实角色，多个代理）

代码背景：模拟人们在12306上抢火车票

Web12306.java：

package 多线程;/** * @author:yb * @version 创建时间：2018-12-25 下午7:36:44 类说明 *//* * 通过runnable接口实现多线程 * 可以方便共享资源，同一份资源，多个代理访问 * 代码背景：模拟人们在web12306上抢火车票 * 共享的是num，票资源 */public class Web12306 implements Runnable {    // 100张火车票    private int num = 50;    // 重写run方法体    public void run() {        while (true) {            if (num <= 0)                break;            System.out.println(Thread.currentThread().getName() + "抢到了火车票"                    + num--);        }    }    public static void main(String[] args) {        // 真实角色        Web12306 web12306 = new Web12306();        // 代理角色1        Thread t1 = new Thread(web12306, "顾客x");        // 代理角色2        Thread t2 = new Thread(web12306, "黄牛y");        // 代理角色3        Thread t3 = new Thread(web12306, "攻城狮z");        // 启动线程        t1.start();        t2.start();        t3.start();    }}

 

记住：线程通过调用start（）方法是使得该进程进入就绪状态而不是运行状态！！！

 

 方法三：线程池实现多线程，继承Callable接口

比较复杂，但是站服务器编程中应用广泛

参考一下这篇博客更好的理解此方法：

代码背景：

还是多线程模拟龟兔赛跑

Call.java:

package 多线程;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;import org.omg.CORBA.INTERNAL;/** * @author:yb * @version 创建时间：2018-12-25 下午8:07:11 类说明 */public class Call {    /*     * 使用Callable创造线程     */    public static void main(String[] args) throws InterruptedException, ExecutionException {        // 创建线程池        ExecutorService service = Executors.newFixedThreadPool(2);        Race tortoise = new Race("乌龟",1000);        Race rabbit = new Race("兔子", 500);                Future
     
       result1 = service.submit(tortoise);        Future
      
        result2 = service.submit(rabbit);                Thread.sleep(3000);//主线程挂起3000ms 乌龟和兔子线程开始竞争cpu 即乌龟和兔子开始跑，跑的时间都是3000ms        tortoise.setFlag(false);        rabbit.setFlag(false);                 //获取值        int num1=result1.get();        System.out.println("乌龟跑了"+num1+"步");        int num2=result2.get();        System.out.println("兔子跑了"+num2+"步");                //停止服务        service.shutdownNow();            }}class Race implements Callable
       
        {        private String name;//名称    private int time;//延时    private int step=0;//步数        public Race(String name,int time) {        super();        this.name=name;        this.time=time;    }        private boolean flag= true;    public int getTime() {        return time;    }    public void setTime(int time) {        this.time = time;    }    public boolean isFlag() {        return flag;    }    public void setFlag(boolean flag) {        this.flag = flag;    }    public int getStep() {        return step;    }    public void setStep(int step) {        this.step = step;    }        public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public Integer call() throws Exception{            while(flag) {            Thread.sleep(time);            step++;            }        return step;    }}
       
      
     

 分析：

通过继承Callable接口实现的多线程，可以对外声明异常和返回值，这是前面两个方法所不能实现的，但是此方法复杂繁琐

 

END！