java--多线程

java---多线程

一、线程简介
    线程：程序可执行的路径，或者说程序可执行的通道
    进程：一个个单独执行的程序或软件
    进程和线程的关系：线程是进程执行的路径、通道，多线程即有多个路径执行这个程序
    一个进程如果只有一个线程，那么这是个单线程程序，如果有多条线程，则为多线程程序
二、生命周期

     
创建多线程的方法：继承Thead父类和实现Runable接口

1、继承Thead
public class TheadDemo extends Thead{
       public void run()
       puclic static void main(String[] args){}
}

public class TheadDemo1 extends Thread {
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"  "+i);
        }
    }
    public static void main(String[] args){
        TheadDemo1 theadDemo1 = new TheadDemo1();
        TheadDemo1 theadDemo2 = new TheadDemo1();
        theadDemo1.start();
        theadDemo2.start();
    }

2、实现Runable接口
public class TheadDemo Implements Runable{
       puclic void run()
       puclic static void main(String[] args){}
}

      public class RunableDemo implements Runnable {
             @Override
                public void run() {
                         for(int i=0;i<100;i++){
                         System.out.println(Thread.currentThread().getName()+""+i);                           //   Thread.currentThread()  获得当前执行线程的信息      getName()   得到线程的名字
                   }
          }
               public static void main(String[] args){
                          RunableDemo runableDemo = new RunableDemo();
                         RunableDemo runableDemo1 = new RunableDemo();
                          Thread thread = new Thread(runableDemo,"线程一");                                           //new Thead(  要创建线程的类对象， 给线程起的名字);
                         Thread thread1 = new Thread(runableDemo1, "线程二");
                         thread.start();
                        thread1.start();
          }
    }
run()方法:当一个线程启动后，就会自动去执行这个方法，当有多个线程的时候每个线程都会去调用run()方法，多个线程是没有执行顺序的，是由cpu随机分配，多个线程依次执行。main()方法主线程是不会去调用外部的run()方法的

两种实现接口方法的区别：

   Thead：

           优点：使用方便          缺点：单继承的局限性

    Runable:

            优点：可以多继承       缺点：使用麻烦

三、常用的方法：

     setPriority(int  new Priority):更改线程的优先级，默认值是5，范围是1-10。1的优先级最低，10的优先级最高

     join():插入：在当前的线程执行中，如果使用join()插入一个线程，那么就会先执行插入的线程，并且要执行完毕才会再执行原来的线程

     sleep(long millis):设置线程休眠，时间以毫秒为单位。设置线程在指定的时间内休眠，不运行。

     yield()暂停正在运行的线程，礼让执行：该方法就像公交车上的让座，被让座的可能接收也可能不接受，所以线程既可能执行原来的也可能执行插入进来的线程

案例：

      slepp和setPriority:

  join():

     public class JoinDemo implements Runnable {
           @Override
            public void run() {
                   for(int i=0;i<10;i++){
                    System.out.println(Thread.currentThread().getName()+" "+i);
                   }
            }
             public static void main(String[] args) throws InterruptedException {
                  JoinDemo joinDemo = new JoinDemo();
                  Thread thread = new Thread(joinDemo);
                  thread.start();
                   for(int i=0;i<10;i++){
                  System.out.println(Thread.currentThread().getName());
                   if(i==3){
                      //join() 插队执行
                  thread.join();
                        //yield() 礼让执行，可能礼让成功，也可能失败
                        //Thread.yield();
                      }
                      }
             }
       }

 四、同步锁

       当多个线程操作同一共享资源时，将引发数据不安全问题，如下：利用线程休眠来模拟网络延迟，多个线程去一家商店买裤子

    public class BuyGoodsDemo implements Runnable {
           private int num=10; //裤子总数
           private int count=0;//购买到的是第几条裤子
          @Override
           public void run() {
                    //每一个人买过之后，num减一，count加一
                 while(true){
                       if(num<=0){
                            //裤子卖完，跳出循环
                             break;
                            }
                         num--;
                         count++;
                           try{
                                   //模拟网络延迟
                                    Thread.sleep(100);
                                }catch (InterruptedException e){
                                    e.printStackTrace();
                                 }
                             System.out.println(Thread.currentThread().getName()+"买到的是第"+count+"条裤子，还有"+num+"条");
                    }
            }
            public static void main(String[] args){
                    BuyGoodsDemo buyGoodsDemo = new BuyGoodsDemo();
                    Thread t1 = new Thread(buyGoodsDemo, "小敏");
                    Thread t2 = new Thread(buyGoodsDemo, "小青");
                     Thread t3 = new Thread(buyGoodsDemo, "小红");
                     Thread t4 = new Thread(buyGoodsDemo, "小白");
                     t1.start();
                        t2.start();
                     t3.start();
                      t4.start();
                     }
       }

执行后的结果：

原因：这时因为当一个线程执行run()方法后，num和count被操作，但是再往后执行就出现了网络延迟，第一个执行的线程还有执行完毕，后边的线程已经将num和count执行了，当网络恢复了，

          第一个线程再向下执行，此时的每个参数数值已经是最后一个线程执行后的参数数值

 解决方法：synchronized:同步锁，将容易出现问题的代码进行包裹，包裹后就成了单线程。

 两种写法：同步代码块和同步方法

第一种：同步代码块：

public class BuyGoodsDemo1 implements Runnable {
/**
* synchronized:同步锁，将容易出现问题的代码进行包裹，包裹后就成为了单线程
* 一、同步代码块（该例中用同步代码块）
* 二、同步方法
* */
private int num=10;
private int count=0;//购买到的是第几条裤子
@Override
public void run() {
//每一个人买过之后，num减一，count加一
while(true){

          //...........................................................................................................................
                  synchronized (this){
                        if(num<=0){
                     //裤子卖完，跳出循环
                           break;
                      }
                      num--;
                       count++;
                       System.out.println(Thread.currentThread().getName()+"买到的是第"+count+"条裤子，还有"+num+"条");
                      }

          //...............................................................................................................................
try{
//模拟网络延迟
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}

}

}
public static void main(String[] args){
BuyGoodsDemo1 buyGoodsDemo = new BuyGoodsDemo1();
Thread t1 = new Thread(buyGoodsDemo, "小敏");
Thread t2 = new Thread(buyGoodsDemo, "小青");
Thread t3 = new Thread(buyGoodsDemo, "小红");
Thread t4 = new Thread(buyGoodsDemo, "小白");
t1.start();
t2.start();
t3.start();
t4.start();
}
}

      第二种：同步方法

public class BuyGoodsDemo2 implements Runnable {
    /**
     * synchronized:同步锁，将容易出现问题的代码进行包裹，包裹后就成为了单线程
     * 一、同步代码块
     * 二、同步方法（该例中用同步方法）
     * */
    private int num=10;
    private int count=0;//购买到的是第几条裤子
    @Override
    public void run() {
        //每一个人买过之后，num减一，count加一
        while(true){

                if(!buy()){
                    break;
                }

            try{
                //模拟网络延迟
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }

        }

    }
    public synchronized boolean buy(){
        if(num<=0){
            //裤子卖完，跳出循环
            return false;
        }
        num--;
        count++;
        System.out.println(Thread.currentThread().getName()+"买到的是第"+count+"条裤子，还有"+num+"条");
        return true;
    }
    public static void main(String[] args){
        BuyGoodsDemo2 buyGoodsDemo = new BuyGoodsDemo2();
        Thread t1 = new Thread(buyGoodsDemo, "小敏");
        Thread t2 = new Thread(buyGoodsDemo, "小青");
        Thread t3 = new Thread(buyGoodsDemo, "小红");
        Thread t4 = new Thread(buyGoodsDemo, "小白");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}








练习：

一、 使用多线程模拟年轻人与老人年徒步爬到1500米的山顶

需求讲解：

年轻人每爬100米需要300毫秒，

老人年爬完100米需要1000毫秒，

利用线程的休眠分别模拟老年人与年轻人每爬100米需要的时间，实现该案例。

二、 利用多线程模拟叫号看病

需求讲解：

1、某科室一天需看普通号50个，特需号10个

2、特需号看病时间是普通号的2倍（设置线程的休眠）

3、开始时普通号和特需号并行叫号（两个线程同时分别被调度），叫到特需号的概率比普通号高（设置线程的优先级）

4、当普通号叫完第10号时，要求先看完全部特需号，再看普通号（join方法）

使用多线程模拟这一过程，执行效果大致如下：

代码：第一题：

public class HomeWorkThead implements Runnable {
    @Override
    public void run() {
      for(int i=0;i<10;i++){
          try {
              Thread.sleep(3000);//设置vip号的诊断时间
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName()+i);
      }

    }
    public static void main(String[] args){
        HomeWorkThead homeWorkThead = new HomeWorkThead();
        Thread thread = new Thread(homeWorkThead,"vip号");
        //设置主线程为普通号
        Thread.currentThread().setName("普通号");
        thread.setPriority(10);//设置vip号的优先级
        thread.start();
        for(int i=0;i<50;i++){
            System.out.println(Thread.currentThread().getName()+i);
            if(i==10){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

第二题代码：

public class HomeWorkThead2 implements Runnable {
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("年轻人")) {
            for (int i = 0; i < 15; i++) {
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "跑完一百米");
                if(i==14){
                    System.out.println(Thread.currentThread().getName()+"跑完了");
                }
            }
        }
        if(Thread.currentThread().getName().equals("老年人")){for (int i = 0; i < 15; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "跑完一百米");
            if(i==14){
                System.out.println(Thread.currentThread().getName()+"跑完了");
            }
        }}
    }
    public static void main(String[] args){
        HomeWorkThead2 h1 = new HomeWorkThead2();
        HomeWorkThead2 h2 = new HomeWorkThead2();

        Thread t1 = new Thread(h1, "年轻人");
        Thread t2 = new Thread(h2, "老年人");

        t1.start();
        t2.start();
    }
}