package com.bjsxt.thread.create;/** * 模拟龟兔赛跑 1、创建多线程  继承  Thread  +重写run(线程体) 2、使用线程: 创建子类对象 + 对象.start()  线程启动      *  * @author Administrator * */public class Rabbit extends Thread {    @Override    public void 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+"步");        }    }}

package com.bjsxt.thread.create;public class RabbitApp {    /**     * @param args     */    public static void main(String[] args) {        //创建子类对象        Rabbit rab = new Rabbit();        Tortoise tor =new Tortoise();                        //调用start 方法        rab.start(); //不要调用run方法        //rab.run();        tor.start();        //tor.run();                for(int i=0;i<1000;i++){            System.out.println("main==>"+i);        }    }}

package com.bjsxt.thread.create;/** * 静态代理 设计模式 * 1、真实角色 * 2、代理角色： 持有真实角色的引用 * 3、二者 实现相同的接口 *  * @author Administrator * */public class StaticProxy {    /**     * @param args     */    public static void main(String[] args) {        //创建真实角色        Marry you =new You();        //创建代理角色 +真实角色的引用        WeddingCompany company =new WeddingCompany(you);        //执行任务        company.marry();    }}//接口interface 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();    }    }

package com.bjsxt.thread.create;/** 推荐  Runnable 创建线程 1)、避免单继承的局限性 2)、便于共享资源      使用 Runnable 创建线程  1、类 实现 Runnable接口 +重写 run()   -->真实角色类  2、启动多线程  使用静态代理    1)、创建真实角色    2)、创建代理角色 +真实角色引用    3)、调用 .start() 启动线程     * @author Administrator * */public class Programmer implements Runnable {    @Override    public void run() {        for(int i=0;i<1000;i++){            System.out.println("一边敲helloworld....");        }    }}

package com.bjsxt.thread.create;public class ProgrammerApp {    /**     * @param args     */    public static void main(String[] args) {         //1)、创建真实角色        Programmer pro =new Programmer();                  //2)、创建代理角色 +真实角色引用        Thread proxy =new Thread(pro);          //3)、调用 .start() 启动线程        proxy.start();                for(int i=0;i<1000;i++){            System.out.println("一边聊qq....");        }    }}

package com.bjsxt.thread.create;/** * 方便共享资源 * @author Administrator * */public class Web12306 implements Runnable {    private int num =50;    @Override    public void run() {        while(true){            if(num<=0){                break; //跳出循环            }            System.out.println(Thread.currentThread().getName()+"抢到了"+num--);        }    }        public static void main(String[] args) {        //真实角色        Web12306 web = new Web12306();        //代理        Thread t1 =new Thread(web,"路人甲");        Thread t2 =new Thread(web,"黄牛已");        Thread t3 =new Thread(web,"攻城师");        //启动线程        t1.start();        t2.start();        t3.start();    }}

package com.bjsxt.thread.status;public class StopDemo01 {    /**     * @param args     */    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;    }    }

package com.bjsxt.thread.status;/** * join:合并线程 * @author Administrator * */public class JoinDemo01 extends Thread {    /**     * @param args     * @throws InterruptedException      */    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阻塞...            }            System.out.println("main...."+i);        }    }        @Override    public void run() {        for(int i=0;i<1000;i++){            System.out.println("join...."+i);        }    }}

package com.bjsxt.thread.status;import java.text.SimpleDateFormat;import java.util.Date;/** * 倒计时 * 1、倒数10个数，一秒内打印一个 * 2、倒计时 * @author Administrator * */public class SleepDemo01 {    /**     * @param args     * @throws InterruptedException      */    public static void main(String[] args) throws InterruptedException {        Date endTime =new Date(System.currentTimeMillis()+10*1000);        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;            }        }    }    public static void test1() throws InterruptedException{        int num =10;        while(true){            System.out.println(num--);            Thread.sleep(1000); //暂停            if(num<=0){                break;            }        }    }    }

package com.bjsxt.thread.status;/** * Sleep模拟 网络延时  线程不安全的类 * @author Administrator * */public class SleepDemo02 {    /**     * @param args     */    public static void main(String[] args) {        //真实角色        Web12306 web= new Web12306();        Web12306 web2 = new Web12306();        //代理        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){                break; //跳出循环            }            try {                Thread.sleep(500);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println(Thread.currentThread().getName()+"抢到了"+num--);        }    }        }

package com.bjsxt.thread.info;/** *  Thread.currentThread()     :当前线程  setName():设置名称  getName():获取名称  isAlive():判断状态 * @author Administrator * */public class InfoDemo01 {    /**     * @param args     * @throws InterruptedException      */    public static void main(String[] args) throws InterruptedException {        MyThread it =new MyThread();        Thread proxy =new Thread(it,"挨踢");        proxy.setName("test");        System.out.println(proxy.getName());        System.out.println(Thread.currentThread().getName()); //main                proxy.start();        System.out.println("启动后的状态:"+proxy.isAlive());        Thread.sleep(200);        it.stop();        Thread.sleep(100);        System.out.println("停止后的状态:"+proxy.isAlive());    }}

package com.bjsxt.thread.info;/** * 优先级:概率，不是绝对的先后顺序   MAX_PRIORITY  10   NORM_PRIORITY 5 (默认)   MIN_PRIORITY  1      setPriority()   getPriority() * @author Administrator * */public class InfoDemo02 {    /**     * @param args     * @throws InterruptedException      */    public static void main(String[] args) throws InterruptedException {        MyThread it =new MyThread();        Thread p1 =new Thread(it,"挨踢1");        MyThread it2 =new MyThread();        Thread p2 =new Thread(it2,"挨踢2");                p1.setPriority(Thread.MIN_PRIORITY); //设置优先级        p2.setPriority(Thread.MAX_PRIORITY);//设置优先级        p1.start();        p2.start();        Thread.sleep(100);        it.stop();        it2.stop();    }}

package com.bjsxt.thread.info;public class MyThread implements Runnable {    private boolean flag =true;    private int num =0;    @Override    public void run() {        while(flag){            System.out.println(Thread.currentThread().getName()+"-->"+num++);        }    }    public void stop(){        this.flag=!this.flag;    }}

package com.bjsxt.thread.syn;/** * 单例设计模式:确保一个类只有一个对象 * @author Administrator * */public class SynDemo02 {    /**     * @param args     */    public static void main(String[] args) {        JvmThread thread1 = new JvmThread(100);        JvmThread thread2 = new JvmThread(500);        thread1.start();        thread2.start();            }}class JvmThread extends Thread{    private long time;    public JvmThread() {    }    public JvmThread(long time) {        this.time =time;    }    @Override    public void run() {                System.out.println(Thread.currentThread().getName()+"-->创建:"+Jvm.getInstance(time));    }}/** * 单例设计模式 * 确保一个类只有一个对象 * 懒汉式  double checking * 1、构造器私有化,避免外部直接创建对象 * 2、声明一个私有的静态变量 * 3、创建一个对外的公共的静态方法 访问该变量，如果变量没有对象，创建该对象 */class Jvm {    //声明一个私有的静态变量    private static Jvm instance =null;        //构造器私有化,避免外部直接创建对象    private Jvm(){            }    //创建一个对外的公共的静态方法 访问该变量，如果变量没有对象，创建该对象    public static Jvm getInstance(long time){        // c d e  -->效率  提供 已经存在对象的访问效率        if(null==instance){                // a b            synchronized(Jvm.class){                if(null==instance ){                    try {                        Thread.sleep(time); //延时 ，放大错误                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    instance =new Jvm();                }            }      }//a      return instance;    }            public static Jvm getInstance3(long time){        //a b c d e  -->效率不高 c  存在对象也需要等待        synchronized(Jvm.class){            if(null==instance ){                try {                    Thread.sleep(time); //延时 ，放大错误                } catch (InterruptedException e) {                    e.printStackTrace();                }                instance =new Jvm();            }            return instance;        }    }            public static synchronized Jvm getInstance2(long time){        if(null==instance ){            try {                Thread.sleep(time); //延时 ，放大错误            } catch (InterruptedException e) {                e.printStackTrace();            }            instance =new Jvm();        }        return instance;    }                public static Jvm getInstance1(long time){        if(null==instance ){            try {                Thread.sleep(time); //延时 ，放大错误            } catch (InterruptedException e) {                e.printStackTrace();            }            instance =new Jvm();        }        return instance;    }}

package com.bjsxt.thread.syn;/** * 过多的同步方法可能造成死锁 * @author Administrator * */public class SynDemo03 {    /**     * @param args     */    public static void main(String[] args) {        Object g =new Object();        Object m = new Object();        Test t1 =new Test(g,m);        Test2 t2 = new Test2(g,m);        Thread proxy = new Thread(t1);        Thread proxy2 = new Thread(t2);        proxy.start();        proxy2.start();    }}class Test implements Runnable{    Object goods ;    Object money ;    public Test(Object goods, Object money) {        super();        this.goods = goods;        this.money = money;    }    @Override    public void run() {        while(true){            test();        }    }    public void test(){        synchronized(goods){            try {                Thread.sleep(100);            } catch (InterruptedException e) {                e.printStackTrace();            }            synchronized(money){            }        }        System.out.println("一手给钱");    }}class Test2  implements Runnable{    Object goods ;    Object money ;    public Test2(Object goods, Object money) {        super();        this.goods = goods;        this.money = money;    }    @Override    public void run() {        while(true){            test();        }    }    public void test(){        synchronized(money){            try {                Thread.sleep(100);            } catch (InterruptedException e) {                e.printStackTrace();            }            synchronized(goods){                            }        }        System.out.println("一手给货");    }    }

package com.bjsxt.thread.pro;/** 一个场景,共同的资源  生产者消费者模式 信号灯法 wait() :等待，释放锁   sleep 不释放锁 notify()/notifyAll():唤醒  与 synchronized * @author Administrator * */public class Movie {    private String pic ;    //信号灯    //flag -->T 生产生产，消费者等待 ，生产完成后通知消费    //flag -->F 消费者消费 生产者等待, 消费完成后通知生产    private boolean flag =true;    /**     * 播放     * @param pic     */    public synchronized void play(String pic){        if(!flag){ //生产者等待            try {                this.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        //开始生产        try {            Thread.sleep(500);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("生产了:"+pic);        //生产完毕                this.pic =pic;        //通知消费        this.notify();        //生产者停下        this.flag =false;    }        public synchronized void watch(){        if(flag){ //消费者等待            try {                this.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        //开始消费        try {            Thread.sleep(200);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("消费了"+pic);        //消费完毕        //通知生产        this.notifyAll();        //消费停止        this.flag=true;    }}

package com.bjsxt.thread.pro;/** * 生产者 * @author Administrator * */public class Player implements Runnable {    private Movie m ;        public Player(Movie m) {        super();        this.m = m;    }    @Override    public void run() {        for(int i=0;i<20;i++){            if(0==i%2){                m.play("左青龙");            }else{                m.play("右白虎");            }        }    }}

package com.bjsxt.thread.pro;public class Watcher implements Runnable {    private Movie m ;        public Watcher(Movie m) {        super();        this.m = m;    }    @Override    public void run() {        for(int i=0;i<20;i++){            m.watch();        }    }}

package com.bjsxt.thread.pro;public class App {    public static void main(String[] args) {        //共同的资源        Movie m = new Movie();                //多线程        Player p = new Player(m);        Watcher w = new Watcher(m);                new Thread(p).start();                new Thread(w).start();    }}

package com.bjsxt.thread.pro;public class TestProduce {    public static void main(String[] args) {        SyncStack sStack = new SyncStack();        Shengchan sc = new Shengchan(sStack);        Xiaofei xf = new Xiaofei(sStack);        sc.start();        xf.start();    }}class Mantou {    int id;    Mantou(int id){        this.id=id;    }}class SyncStack{    int index=0;    Mantou[] ms = new Mantou[10];        public synchronized void push(Mantou m){        while(index==ms.length){            try {                this.wait();                 //wait后，线程会将持有的锁释放。sleep是即使睡着也持有互斥锁。            } catch (InterruptedException e) {                e.printStackTrace();            }        }        this.notify(); //唤醒在当前对象等待池中等待的第一个线程。notifyAll叫醒所有在当前对象等待池中等待的所有线程。        //如果不唤醒的话。以后这两个线程都会进入等待线程，没有人唤醒。        ms[index]=m;        index++;    }    public synchronized Mantou pop(){        while(index==0){            try {                this.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        this.notify();        index--;        return ms[index];    }}class Shengchan extends Thread{    SyncStack ss = null;        public Shengchan(SyncStack ss) {        this.ss=ss;    }    @Override    public void run() {        for (int i = 0; i < 20; i++) {            System.out.println("造馒头："+i);            Mantou m = new Mantou(i);            ss.push(m);        }    }}class Xiaofei extends Thread{    SyncStack ss = null;        public Xiaofei(SyncStack ss) {        this.ss=ss;    }    @Override    public void run() {        for (int i = 0; i < 20; i++) {            Mantou m = ss.pop();            System.out.println("吃馒头："+i);                    }    }}

package com.bjsxt.thread.schedule;import java.util.Date;import java.util.Timer;import java.util.TimerTask;/**    了解  Timer()   schedule(TimerTask task, Date time)   schedule(TimerTask task, Date firstTime, long period)   自学 quartz * @author Administrator * */public class TimeDemo01 {    /**     * @param args     */    public static void main(String[] args) {        Timer timer =new Timer();        timer.schedule(new TimerTask(){            @Override            public void run() {                System.out.println("so easy....");            }}, new Date(System.currentTimeMillis()+1000), 200);    }}