一个基础的多线程问题，记录学习多线程

一：创建多线程的方法

：
A：继承Thread类，重写run()方法；
B：实现Runnable接口，重写run()方法；

二：两种实现的区别

：
1.在于实现和继承的区别：单继承，多实现；
2.在于资源共享的区别：继承Thread不利于资源共享（故推荐使用实现接口的方法去创建多线程）

三：线程状态

新生状态: 创建了线程对象
可运行状态: 已经交由JVM处理
运行状态: 被CPU调度后
死亡状态:线程正常运行结束， 人为停止
阻塞状态:改变线程现有的执行状态
join:插队： 主线程要等待子线程(加入join)执行完后再执行
yield:暂停： 状态变为可运行状态，交由同等优先级或优先级高的线程去执行
sleep:休眠：暂时休眠，在休眠期，自己不会被再次执行， 其他线程(优先级低的也可)有机会执行到

四、线程优先级:

最大:10
默认:5
最小:1

五、线程同步

同步：某个时间段只允许单个线程执行某个操作加锁
异步:同时执行多个方法

实现方式
1.方法同步
eg:public synchronized void run() {
2.同步代码块
eg:
synchronized(this){
int tickets = 100;
if(tickets>0){
tickets–;
System.out.println(Thread.currentThread().getName()+”正在售票，剩余票数:”+tickets);
}
}
推荐使用:同步代码块
方法同步操作范围比较大，会严重影响执行效率

同步锁(this):
必须是一个非空对象
private Object obj = new Object();
synchronized(obj){
}
private Dog dog = new Dog();
synchronized(dog){
}

六：举例实现一个多线程程序

name：小明和闹钟的故事
quest：闹钟响三次，小吴醒来关掉闹钟，执行五次，休眠时间为三秒；

Implements:
三个基础类：
A：主人公小吴
B：闹钟
C：测试类
code：
小吴的类：

public class Wu implements Runnable{
    //成员变量：传一个闹钟类的对象
    private Clock clock;
    //分别创建无参构造方法和有参构造方法
    public Wu(){}
    public Wu(Clock clock){
        this.clock = clock;
    }

    public Clock getClock() {
        return clock;
    }

    public void setClock(Clock clock) {
        this.clock = clock;
    }

    @Override
    public void run() {
        //执行weak()方法
        try {
            while(true){
                weak();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 醒来
     * @throws InterruptedException 
     */
    public void weak() throws InterruptedException{
        synchronized(clock){
            //判断闹钟的状态
            if(clock.isRing()){
            System.out.println(Thread.currentThread().getName()+":知道了...\n");
            //关闭闹钟后，再次设置闹钟的状态为false
                clock.setRing(false);
                //设置线程的休眠时间（3秒）
                Thread.sleep(3000);
                //唤醒线程→等待线程
                clock.notifyAll();
                clock.wait();
            }else{
                //等待线程
                clock.wait();
                //唤醒线程
                clock.notifyAll();
            }
        }
    }

}

闹钟的类：

public class Clock implements Runnable{
    //创建一个boolean类型的成员变量标识闹钟状态，并初始化状态为false
    private boolean isRing = false;
    //Getters和Setters方法
    public boolean isRing() {
        return isRing;
    }

    public void setRing(boolean isRing) {
        this.isRing = isRing;
    }

    @Override
    public void run() {
        //执行五次主线程
        for(int i=0;i<5;i++){
            try {
                ring();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 闹钟
     * @throws InterruptedException 
     */
    public void ring() throws InterruptedException{
        synchronized(this){
            //判断isRing的状态是true还是flase，从而给出不同的方法
            if(!isRing){
                for(int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName()+"叮叮当");
                }
                //将闹钟表示为已经响过了
                this.setRing(true);
                //唤醒线程→等待线程
                this.notifyAll();
                this.wait();
            }else{
                //等待线程
                this.wait();
                //唤醒线程
                this.notifyAll();
            }
        }
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //创建闹钟对象
        Clock clock = new Clock();
        //创建小吴对象
        Wu wu = new Wu(clock);
        //创建线程
        Thread wuThread = new Thread(wu,"小吴");
        Thread clockThread = new Thread(clock,"闹钟");
        //设置后台线程：小吴
        wuThread.setDaemon(true);
        //启动线程
        wuThread.start();
        clockThread.start();
    }
}

学习多线程的一些心得：
刚接触多线程的学习，真的是被线程状态和如何在程序中应用多线程搞得一头雾水，那么如何在写程序的时候很好的利用多线程呢？
我个人认为最好的方法，就是把程序和实际生活中的尝试结合起来。我举一个简单的例子吧，有这样一个需求：
人和事物分别是：两个人和一个水桶
动作：一个人用水桶去接水，一个人喝掉水桶里的水
状态：水桶中是否有水（isEmpty）

---

我的思路是这样的：
1.四个基本类：
A：路人甲
B：路人乙
C：水桶
D：测试类
2.路人甲中的内容：
A：判断水桶是否为空：
true：接水→设置isEmpty为false→唤醒水桶→等待线程
false：等待线程→唤醒线程
B：run()方法去调用A方法，执行一定的次数
C：加入线程同步

3.路人乙中的内容：
A：判断水桶是否为空：
true：等待线程→唤醒线程
false：喝水→设置isEmpty为true→唤醒水桶线程→等待线程
B：run()方法去调用A方法，执行一定的次数 （可以用while循环，一旦主线程停止，停止这个线程）
C：加入线程同步

4.水桶中的内容：
A：设置成员变量：isEmpty，并初始化为true
B：Getters和Setters方法
C：有参无参构造，用于创建水桶对象

5.测试类中的内容：
A：创建路人甲、路人乙对象
B：创建路人甲、路人乙的线程
C：设置后台线程
D：启动线程