线程基础

1、线程状态：

• 新生状态

用new关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新生状态，处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态（rumnable）

 

• 就绪状态

处于就绪状态的线程已经具备了运行的条件，但还没有分配到cpu，处于线程就绪队列，等待系统为其分配CPU，等待状态并不是执行状态，当系统选定一个等待执行的Thread对象后，他/她就会从等待执行状态进入执行状态，系统挑选的动作称之为“CPU调度”。一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。

• 运行状态

在运行状态的线程执行自己的run方法中代码，知道调度其他方法而终止、或等待某资源而阻塞或完成任务而死亡。如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态

• 阻塞状态

处于运行状态的线程在某些情况下，如执行了sheep(睡眠)方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入阻塞状态，在阻塞状态的线程不能进入就绪队列，只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续运行。

• 死亡状态

死亡状态是线程生命周期中的最后一个阶段，线程死亡的原因有两个。一个是正常运行的线程完成了它全部工作，另一个是线程被强制性的终止，如通过执行stop或destroy方法来终止一个线程（不推荐使用这两个方法，前者会产生异常，后者是强制终止，不会释放锁）

 

2、停止线程

1）自然终止：线程体正常执行完毕

2）外部干涉

1、在线程类中定义线程体使用的标识

2、线程体使用该标识

3、提供对外的方法改变该标识

4、外部根据条件调用该方法即可

 

3、阻塞

1） join:合并线程

2）yield:暂停自己的线程   静态方法

3） sleep:休眠，不释放锁

*与时间相关:倒计时

*模拟网络延时

 

4、线程的同步（并发）

1）由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。

2）由于我们可以通过private关键字来保证数据对象只能被方法访问，所有我们只需针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块。

同步：多个线程访问同一份资源  确保资源安全--->线程安全

• 同步块

synchronized(引用类型|this|类.class){

}

• 同步方法

public synchronized void test1(){

}

线程安全：保证资源安全，相对效率低

锁定范围过大：效率低下

锁定范围过小：没有保证资源安全

 

例1：

public class SynDemo1 {
    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.getInstance1(time));
    }
}
 
/**
 * 单例设计模式
 * 确保一个类只有一个对象
 * 懒汉式（使用的创建对象）：
 *         1、构造器私有化，避免外部直接创建对象
 *         2、声明一个私有的静态变量
 *         3、对外提供一个公共的静态方法访问该变量，
 *              如果变量没有对象，创建对象，否则直接返回
 * @author qjc
 *
 * 2016-3-13
 */
class Jvm{
    private static Jvm instance = null;
    private Jvm() {
    }
    //线程不安全
    public static Jvm getInstance1(long time){
        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 getInstance3(long time){
        //a b c d e都在此等待 -->效率不高 存在对象也需要等待
        synchronized (Jvm.class) {  //静态代码块里没有this
            if(null==instance){   //安全
                try {
                    Thread.sleep(time);//延时 放大错误
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                instance = new Jvm();
            }
            return instance;
        }
    }
    //double checking 双重检查
    public static Jvm getInstance4(long time){
        //b c d e 直接返回对象-->效率 提供已经存在对象的访问效率
        if(null==instance){
            //a 创建对象
            synchronized (Jvm.class) {  //静态代码块里没有this
                if(null==instance){  //安全
                    try {
                        Thread.sleep(time);//延时 放大错误
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance = new Jvm();
                }
            }
        }
        return instance;
    }
}

5、死锁

建立在同步之上，过多的同步容易造成死锁

 

例2：

/**
 * 过多同步容易造成死锁
 * @author qjc
 *
 * 2016-3-13
 */
public class SynDemo2 {
    public static void main(String[] args) {
        Object goods = new Object();
        Object money = new Object();
        Test t1 = new Test(goods,money);
        Test t2 = new Test(goods,money);
        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(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (money) {
            }
        }
        System.err.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.err.println("一手给货");
    }
}

解决死锁方法：生产者消费者模式（不是设计模式）

• 生产者消费者问题，也称有限缓冲问题，是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程----即所谓的“生产者”和“消费者” ---在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。在此同时，消费者也在缓冲区消费这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。
• 要解决该问题，就必须谈生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。通常常用的方法由信号灯法、管程等。如果解决方法不够完善，则容易出现死锁的情况。出现死锁时，两个线程都会陷入休眠，等待对方唤醒自己。

 

例3：

/**
 * 一个场景，共同的资源
 * 生产者消费者模式：信号灯法
 *     wait():等待，释放锁
 *      sleep()：不释放锁
 *      notify()/notifyAll():唤醒
 * @author qjc
 *
 * 2016-3-13
 */
public class Movie {
    private String pic;
    /**
     * 信号灯
     *     flag = T 生产者生产，消费者等待,生产完成后通知消费
     *     flag = F 消费者消费，生产者等待，消费完后通知生产
     */
    private boolean flag = true;
    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);
        //消费完毕
        System.out.println("消费了"+pic);
        //通知生产
        this.notifyAll();
        //消费停止
        this.flag = true;
    }
}
 
 
/**
 * 生产者
 * @author qjc
 *
 * 2016-3-13
 */
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("右白虎");
            }
        }
    }
}
 
/**
 * 消费者
 * @author qjc
 *
 * 2016-3-13
 */
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();
        }
    }
}
 
/**
 * 测试
 * @author qjc
 *
 * 2016-3-13
 */
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(); 
    }
}

sleep()与wait()区别

 

对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。

 

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

 

在调用sleep()方法的过程中，线程不会释放对象锁。

 

而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

 

获取对象锁进入运行状态。

 

 

6、任务调度

• Timer 定时器类
• TimerTask 任务类
• 通过java timer timertask :（spring的任务调度就是通过他们来实现的）
• 在这种实现方式中，Timer类实现的是类似闹钟的功能，也就是定时或者每个一定时间触发一次线程。其实，Timer类本身实现的就是一个线程，只是这个线程是用来实现调用其他线程的。而TimerTask类似一个抽象类，该类实现了Runnable接口，所以按照前面的介绍，该类具备多线程的能力。
• 在这种实现方式中，通过继承TimerTask是该类获得多线程的能力，将需要多线程执行的代码书写在run方法内部，然后通过Timer类启动线程的执行。
• 在实际使用时，一个Timer可以启动任意多个TimerTask实现线程，但是多个线程之间会存在阻塞。所以如果多个线程之间如果需要完全独立运行的话，最好还是一个Timer启动一个TimerTask实现。

例4：

/**
 * @author qjc
 *
 * 2016-3-13
 */
public class TimeDemo {
    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)
        , 500);//参数3：每隔500秒调用一次，没有参数3只调用一次
    }
}

第三方框架：quartz   juc

 

 

7、总结

 

1、创建线程：

1. 继承Thread
2. 实现Runnable

3. 实现Callable

2、线程状态

1）新生-->start -->就绪-->运行-->阻塞-->终止

2）终止线程

3）阻塞：join yield sleep  

 

 

3、线程的信息

   1）Thread.currentThread

 2) 获取名称设置名称设置优先级判断状态

 

4、同步 ----对同一份资源