一、程序、进程、线程1.程序：程序就是我们编写的代码，也就是指令集，是一个静态概念。2.进程：操作系统调度我们的程序，动态概念，一个程序就是一个进程。进程是程序的一次动态执行过程，占用特定的地址空间，每个进程是独立的，由3部分组成：cpu,data(数据)，code(代码区)。缺点：内存浪费，cpu会有负担。3.线程：是进程中的一个单一的执行路径，线程又被称为轻量级的进程。一个进程可以拥有多个并行的线程。一个进程中的线程共享内存单元/内存地址空间，多个线程可以共享数据，可以访问相同的变量和对象，是从同一堆中分配对象。所以有一个并发的问题，一份数据多个线程来用。由于线程间的通信是在同一地址空间进行，所以不需要额外的通信机制，一个程序就有一个进程，每个进程有独立的代码和数据空间，进程间的切换有较大的开销。多进程是操作系统能同时运行多个任务（程序），多线程是在同一应用程序中有多个执行流程。系统为每个进程分配不同的内存区域，不会为线程分配内存（因为线程在进程中），线程是进程的一部分，所以线程也被成为轻量级进程。线程在java中也是类和接口，进程包含线程，线程是进程的一部分，线程是不同的执行路径，多线程就是有多核，多个cpu。cpu有一个调度，有一个时间片，时间片非常的小。main方法是一个主线程，就是一条路径。线程创建的第一种方式：/** * 模拟龟兔赛跑 1、创建多线程  继承  Thread  +重写run(线程体) 2、使用线程: 创建子类对象 + 对象.start()  线程启动 */public class Rabbit extends Thread {    @Override    public void run() {
   //线程体，一切从run开始就像main方法一切从main开始，这个运行一切从run开始。        for(int i=0;i<100;i++){            System.out.println("兔子跑了"+i+"步");        }    }}class Tortoise extends Thread {    @Override    public void run() {        //线程体        for(int i=0;i<100;i++){            System.out.println("乌龟跑了"+i+"步");        }    }}public class RabbitApp {    public static void main(String[] args) {
   //main也是一个线程有自己的路径。        //创建子类对象        Rabbit rab = new Rabbit();        Tortoise tor =new Tortoise();        //调用start 方法，内部由cpu调用他们，start()只是加到线程里面。        rab.start();         //rab.run();//不要调用run方法，调用run方法不是启动线程而是普通方法的调用。程序会从上到下依次调用执行。        tor.start();        //tor.run();        for(int i=0;i<100;i++){            System.out.println("main==>"+i);        }        /*main==>96        main==>97        main==>98        main==>99        乌龟跑了0步        乌龟跑了1步        乌龟跑了2步        兔子跑了14步        兔子跑了15步        兔子跑了16步        兔子跑了17步*/            }//rab.start(); 和    tor.start();和 main()的for(int i=0;i<100;i++){System.out.println("main==>"+i);}3者交替执行}第二种实现多线程的方式：继承Thread类方式的缺点是如果一个类已经从另一个类继承则无法再继承Thread类。所以通过实现Runnable接口，有点是可以实现同时继承。Runnable接口用到了静态代理设计模式,下面先看看静态代理设计模式。/** * 静态代理 设计模式（静态代理的时候WeddingCompany是写死的，动态代理的时候WeddingCompany是动态创建的，也就是说代理对象是动态的）（代理就是代别人做事，被代理就是别人做事都是做的自己的事） * 代理的要求： * 1、真实角色 * 2、代理角色： 持有真实角色的引用 * 3、二者 实现相同的接口（代理去实现这个方法也就是被代理的去实现这个方法） */public class StaticProxy {    public static void main(String[] args) {        //创建真实角色        Marry you =new You();        //创建代理角色 +真实角色的引用        WeddingCompany company =new WeddingCompany(you);        //执行任务        company.marry();    }}//接口interface Marry{    void marry();//相当于public abstract void marry();接口里面的方法都是公共的抽象的}//真实角色class You implements Marry{    @Override    public void marry() {        System.out.println("you and  嫦娥结婚了....");    }}//代理角色class WeddingCompany implements Marry{    private Marry you;    public WeddingCompany() {    }    public WeddingCompany(Marry you) {        this.you = you;    }    private void before(){        System.out.println("布置猪窝....");            }    private void after(){        System.out.println("闹玉兔....");    }    @Override    public void marry() {        before();        you.marry();        after();    }}静态代理 + Runnable接口实现多线程：/** 推荐  Runnable 创建线程 1)、避免单继承的局限性（继承接口后还可以继承其他类） 2)、便于共享资源    使用 Runnable 创建线程  1、类 实现 Runnable接口 +重写 run() --> 真实角色类  2、启动多线程  使用静态代理    1)、创建真实角色    2)、创建代理角色 +真实角色引用    3)、调用 .start() 启动线程 */public class Programmer implements Runnable {    @Override    public void run() {        for(int i=0;i<1000;i++){            System.out.println("一边敲helloworld....");        }    }}public class ProgrammerApp {    public static void main(String[] args) {
   //main也是一个线程有自己的路径。         //1)、创建真实角色        Programmer pro =new Programmer();          //2)、创建代理角色 +真实角色引用        Thread proxy =new Thread(pro);//Thread和Programmer一样实现了Runnable接口，proxy代理别人做事，所以proxy是代理，Programmer是被代理。所以这里用到了静态代理模式。          //3)、调用 .start() 启动线程        proxy.start();        for(int i=0;i<1000;i++){            System.out.println("一边聊qq....");        }    }}/** * 方便共享资源 */public class Web12306 implements Runnable {    private int num =10;//50张票    @Override    public void run() {        while(true){            if(num<=0){                break; //跳出循环            }            System.out.println(Thread.currentThread().getName()+"抢到了"+num--);        }    }        public static void main(String[] args) {
   //这个线程的名字是main        //真实角色        Web12306 web = new Web12306();        //public class Thread implements Runnable {}        //静态代理模式，Thread和Web12306都实现了Runnable接口，        // public Thread(Runnable target, String name) {}        Thread t1 =new Thread(web,"路人甲");//线程t1的名字        Thread t2 =new Thread(web,"黄牛已");//线程t2的名字        Thread t3 =new Thread(web,"攻城师");//线程t3的名字        //启动线程        t1.start();//start()就启动了线程        t2.start();        t3.start();        /*路人甲抢到了9        黄牛已抢到了10        黄牛已抢到了8        黄牛已抢到了7        黄牛已抢到了6        黄牛已抢到了5        黄牛已抢到了3        黄牛已抢到了2        黄牛已抢到了1        攻城师抢到了4*/    }}线程：一、继承Thread,重写run()方法，启动：创建子类对象+对象.start()二、实现Runnable，重写run(),启动：使用静态代理，1.创建真实角色，2.创建代理角色（Thread），3.代理角色.start()实现Runnable，重写run()的缺点是不能拋异常，没有返回值，因此使用Callable接口解决这个问题。使用Callable创建线程比较繁琐，优点是又返回值并且可以对外申明异常。通过Callable接口实现多线程优点：可以获取返回值Callable和Future接口，Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable接口的类都是可被其他线程执行的任务。Callable和Runnable有几点不同：1.Callable规定的方法是call(),而Runnable规定的方法是run()2.call()可抛出异常，而run()是不能抛出异常的3.Callable的任务执行后可返回值，运行Callable任务可以拿到一个Future对象，而Runnable任务是不能返回值的，Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行的情况，可取消任务的执行，还可以获取任务的执行结果。缺点：繁琐步骤：1.创建Callable实现类，重写call方法。2.借助执行调度服务ExecutorService获取Future对象。ExecutorService  ser=Executors.newFixedThreadPool(2);Future result =ser.submit(实现类对象) ;3.获取值result.get();4.停止服务ser.shutdownNow();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;/** * 使用Callable创建线程 */public class Call {    public static void main(String[] args) throws InterruptedException, ExecutionException {        //创建2个线程        ExecutorService  ser=Executors.newFixedThreadPool(2);                Race tortoise = new Race("老不死",1000);        Future
     
       result1 =ser.submit(tortoise) ;//让线程执行tortoise，获取值，        tortoise.setFlag(false); //停止线程体循环        int num1 =result1.get();//进入call方法        System.out.println("乌龟跑了-->"+num1+"步");                        Race rabbit = new Race("小兔子",500);        Future
      
        result2 =ser.submit(rabbit) ;        rabbit.setFlag(false);        int num2 =result2.get();        System.out.println("小兔子跑了-->"+num2+"步");                        Thread.sleep(2000); //2秒        ser.shutdownNow();//停止服务     }}class Race implements Callable
       
        {
   //继承Callable接口，重写call方法。    private String name ; //名称    private long time; //延时时间    private boolean flag =true;    private int step =0; //步    public Race() {    }        public Race(String name) {        super();        this.name = name;    }    public Race(String name,long time) {        super();        this.name = name;        this.time =time;    }    @Override    public Integer call() throws Exception {
   //有返回值，并且可以申明异常。        while(flag){            Thread.sleep(time); //延时            step++;        }        return step;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public long getTime() {        return time;    }    public void setTime(long 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;    }}线程的状态：1.线程创建。2.调用start()方法，线程进入就绪状态。3.cpu调度，线程进入运行状态。4.任务完成，线程终止。5.线程运行过程中，出现导致阻塞的事件，线程进入阻塞状态，阻塞解除后，线程又进入就绪状态。（阻塞接触后是进入就绪状态不是运行状态）。线程干涉：线程体通过标示符，外部通过条件调用。public class StopDemo01 {    public static void main(String[] args) {        Study s =new Study();        new Thread(s).start();                //外部干涉        for(int i=0;i<100;i++){            if(50==i){ //外部干涉                s.stop();            }            System.out.println("main.....-->"+i);        }    }}class Study implements Runnable{     //1)、线程类中 定义 线程体使用的标识         private boolean flag =true;    @Override    public void run() {        //2)、线程体使用该标识        while(flag){            System.out.println("study thread....");        }    }    //3)、对外提供方法改变标识    public void stop(){        this.flag =false;    }}阻塞：1.join:合并线程。2.yeld:暂停自己，让别的线程执行。3.sleep:休眠,休眠的时候不会释放锁。常用于与时间相关的和模拟网络延时。/** * join:合并线程 */public class JoinDemo01 extends Thread {    public static void main(String[] args) throws InterruptedException {        JoinDemo01 demo = new JoinDemo01();        Thread t = new Thread(demo); //新生        t.start();//就绪        //cpu调度 运行        for(int i=0;i<1000;i++){            if(50==i){                t.join(); //main阻塞...一定要等到t的线程执行完main才能开始执行。            }            System.out.println("main...."+i);        }    }        @Override    public void run() {        for(int i=0;i<1000;i++){            System.out.println("join...."+i);        }    }}public class YieldDemo01 extends Thread {    public static void main(String[] args) {        YieldDemo01 demo = new YieldDemo01();        Thread t = new Thread(demo); //新生        t.start();//就绪        //cpu调度 运行        for(int i=0;i<1000;i++){            if(i%20==0){                //暂停本线程 main，yield是一个静态方法，写在哪个线程体里面就暂停谁。之后什么时候再次调用是由cpu的调度算法决定的。                Thread.yield();            }            System.out.println("main...."+i);        }    }        @Override    public void run() {        for(int i=0;i<1000;i++){            System.out.println("yield...."+i);        }    }}/** * 倒计时 * 1、倒数10个数，一秒内打印一个 * 2、倒计时 */public class SleepDemo01 {    public static void main(String[] args) throws InterruptedException {        Date endTime =new Date(System.currentTimeMillis()+10*1000);//当前时间加上10秒        long end =endTime.getTime();        while(true){            //输出            System.out.println(new SimpleDateFormat("mm:ss").format(endTime));            //等待一秒            Thread.sleep(1000);            //构建下一秒时间            endTime =new Date(endTime.getTime()-1000);            //10秒以内 继续 否则 退出            if(end-10000>endTime.getTime()){                break;            }        }        /*17:56 17:55 17:54 17:53 17:52 17:51 17:50 17:49 17:48 17:47 17:46*/    }    public static void test1() throws InterruptedException{        int num =10;        while(true){            System.out.println(num--);            Thread.sleep(1000); //暂停            if(num<=0){                break;            }        }    }}/** * Sleep模拟 网络延时  线程不安全的类 */public class SleepDemo02 {    public static void main(String[] args) {        //真实角色        Web12306 web= new Web12306();        Web12306 web2 = new Web12306();        //3个代理同时操控一个被代理对象，        Thread t1 =new Thread(web,"路人甲");        Thread t2 =new Thread(web,"黄牛已");        Thread t3 =new Thread(web,"攻城师");        //启动线程        t1.start();        t2.start();        t3.start();    }}class Web12306 implements Runnable {    private int num =50;    @Override    public void run() {        while(true){            if(num<=0){
   //num=1时，当a、b、c依次进来后依次开始睡眠。                break; //跳出循环            }            try {                Thread.sleep(5000);///sleep也是暂停线程的一种方式.休眠的时候不会释放锁，            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println(Thread.currentThread().getName()+"抢到了"+num--);        }//a醒了以后带走了1，b醒了以后带走了0，c醒了以后带走了-1。    }}