多线程 简介与实例

程序

只是一组指令的有序集合。
二

• 进程

是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是系统进 行资源分配和调度的一个独立单位;
　

• 线程

是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),一个线程可以创建和撤销另一个线程;

任何一个程序都有一个主线程，我们自己开启的都是 子线程。

类实现：
1:自定义一个线程 thread 类 继承thread
2:重写run 这个方法
3:在测试类里面 new
4:启动线程是 start 而不是run。

接口实现：
实现这样一个接口 runnable
只有一个方法就是 run（）

为什么要使用接口来处理共享资源的线程。
1:避免了继承的单一性
2:方便对共享资源的处理

jvm在线程里面是守护线程，等待所有线程执行后进行回收

synchronized 在使用的过程中注意这样一个坑 在使用非静态的时候 直接this关键字作为对象锁 .在使用静态的时候，使用开辟线程的类作为锁的对象，如果为了省事 可以直接使用Object.class(确保唯一性)

线程通信
wait 让当前线程阻塞
notify 唤醒另一个线程（适用于只有两个线程的时候）
notifyAll 唤醒其他所有线程（适用于多个线程存在的时候）
wait notify/notifyAll 这 两个方法不属于线程的方法 属于object的api方法
wait和notify必需和 synchronized一起使用

生产者 和 消费者模式
这个就是线程的调度
不能无限制的生产，也不能无限制的消费。期间需要使用wait和notify进行线程之间的通信调度。

1:需要一个类作为载体
2:需要消费的线程
3:需要生产的线程

最终会达到一个动态平衡。

常用api
setName 设置线程的名字
getName
start();
sleep(毫秒数)
currentthread

yield join 代表当前线程执行完后再执行其他线程，他必须放在start方法后面才能同步，否则还是会交替执行
//join中的参数代表会让当前线程执行参数中的时间后，再让两个线程并行执行。join(0)等价于join()

线程的生命周期

线程的开始 new Thread

线程的就绪 runnable

线程的执行 run

线程的销毁 run结束后，或destory

两个简单的例子：
1.两个人向银行存钱，共存6000，要考虑线程安全问题

public class ThreadDemo2 {
    public static void main(String[] args) {
        Despoit de=new Despoit();
        ThreadDespoit td=new ThreadDespoit(de);
        Thread td1=new Thread(td,"张三");
        Thread td2=new Thread(td,"李四");

        td1.start();td2.start();
    }
}


----------


``

public class Despoit {
    private int count=0; //账户
    public synchronized void SaveMoney(int money){
          notify();
          try {
              count=count+money;
              System.out.println(Thread.currentThread().getName()+"存了1000，账户余额"+count);
              wait();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }

}


----------


``

public class ThreadDespoit implements Runnable{
    Despoit despoit;

    public ThreadDespoit(Despoit despoit) {
        super();
        this.despoit = despoit;
    }


    @Override
    public void run() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        for(int i=0;i<3;i++){
                despoit.SaveMoney(1000);
        }
    }

}

运行结果：
张三存了1000，账户余额1000
李四存了1000，账户余额2000
张三存了1000，账户余额3000
李四存了1000，账户余额4000
张三存了1000，账户余额5000
李四存了1000，账户余额6000

2.生产者–消费者模式：

public class ThreadSuperMark {
    public static void main(String[] args) {
         SuperMarket sm=new SuperMarket();
        NFSQ nf=new NFSQ(sm);
        XiaoFei xf=new XiaoFei(sm);
        Thread td=new Thread(nf,"农夫山泉");
        Thread td2=new Thread(xf,"消费者1号");
        Thread td3=new Thread(xf,"消费者2号");

        td.start();
        td2.start();
        td3.start();
    }
}

———-农夫山泉代表生产者

public class NFSQ implements Runnable{
    SuperMarket sm;
    public NFSQ(SuperMarket sm) {
        this.sm=sm;
    }
    @Override
    public void run() {
        for(int i=0;i<50;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        sm.shenchan();
        }
    }

}

———-消费者

public class XiaoFei implements Runnable{

    SuperMarket sm;
    public XiaoFei(SuperMarket sm) {
        this.sm=sm;
    }
    @Override
    public void run() {
        for(int i=0;i<50;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        sm.xiaofei();
        }
    }

}

———-超市

public class SuperMarket {

    //默认初始状态的水
    private int bottle=1;

    //生产
    public synchronized void shenchan(){

        notifyAll();

        if(bottle>50){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        bottle++;
        System.out.println("生产了1瓶水,当前数量:"+bottle);


    }
    //消费
    public synchronized void xiaofei(){
        notifyAll();
        if(bottle<5){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
        bottle--;
        System.out.println("消费了1瓶水,剩余数量："+bottle);
        }

    }
}

运行结果：
生产了1瓶水,当前数量:2
生产了1瓶水,当前数量:3
生产了1瓶水,当前数量:4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
生产了1瓶水,当前数量:6
消费了1瓶水,剩余数量：5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
生产了1瓶水,当前数量:6
消费了1瓶水,剩余数量：5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
生产了1瓶水,当前数量:6
消费了1瓶水,剩余数量：5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
生产了1瓶水,当前数量:6
消费了1瓶水,剩余数量：5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
生产了1瓶水,当前数量:6
消费了1瓶水,剩余数量：5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4
生产了1瓶水,当前数量:5
消费了1瓶水,剩余数量：4