线程（一）

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);
    }

}