Day40 实现多线程

实现多线程

1. 进程：正在运行的程序（是系统进行资源分配和调用的独立单位；每个进程都有自己的内存空间和系统资源）

2. 线程：进程种的单个顺序控制流，是一条执行路径（单线程：一个进程只有一条执行路径，为单线程程序 多线程：一个进程有多条执行路径，为多线程程序）

3. 多线程实现方法：方式1：继承Thread类（定义一个类MyThread继承Thread类；在MyThread类中重写run()方法；创建MyThread类的对象；启动线程）

public class MyThread extends Thread{
    @Override
    public void run(){
        for(int i=0;i<100;i++){
        System.out.println(i);  
        }
    }
}
​
public class MyThreadDemo{
    public static void mian(String[] args){
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        //启动线程（run方法没有启动线程）
        //void start（）导致此线程开始执行；Java虚拟机调用此线程的run方法
       // my1.run();
       // my2.run();
        my1.start();
        my2.start();
    }
}

1. 设置和获取线程名称：void setName(String name):将此线程的名称更改为等于参数name String getName():返回此线程的名称

   //还可以通过构造方法设置线程名称 //获取main（）方法所在的线程名称：public static Thread currentThread();返回对当前正在执行的线程对象的引用。

public class MyThread extends Thread{
    @Override
    public void run(){
        for(int i=0;i<100;i++){
        System.out.println(getName()+":"+i);    
        }
    }
}
​
public class MyThreadDemo{
    public static void mian(String[] args){
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        //void setName(String name):将此线程的名称更改为等于参数name
        my1.setName("高铁");
        my2.setName("飞机");
        //启动线程
        my1.start();
        my2.start();
    }
}

1. 线程调度： 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片

   抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些。

Java使用抢占式调度模型，CPU在某一个时刻只能执行一条指令，线程只有得到CPU时间片才可以执行指令。因此多线程程序的执行 是有随机性。

Thread类中设置和获取线程优先级的方法：public final int getPriority():返回此线程的优先级

public final void setPriority(int newPriority):更改此线程的优先级（线程默认优先级5，优先级范围是1-10）

public class MyThread extends Thread{
    @Override
    public void run(){
        for(int i=0;i<100;i++){
        System.out.println(getName()+":"+i);    
        }
    }
}
public class ThreadPriorityDemo{
    public static void main(String[] args){
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriotity();
        ThreadPriority tp3 = new ThreadPriority();
        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");
        //public final int getPriority():返回此线程的优先级
        // System.out.println(tp1.getPriority());//5
        //public final void setPriority(int newPriority)：更改此线程的优先级
        System.out.println(Thread.MAX_PRIORITY);//最大10
        System.out.println(Thread.MIN_PRIORITY);//最小1
        System.out.println(Thread.MORN_PRIORITY);//默认5
        //设置正确的优先级
        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);
        //线程优先级高只能说明获取cpu时间片的机率高，不一定就能按级数获取
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

1. 线程控制

   方法名	说明
   static void(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数
   void join()	等待这个线程死亡
   void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

   public class MyThread extends Thread{
       @Override
       public void run(){
           for(int i=0;i<100;i++){
           System.out.println(getName()+":"+i);
              try{ Thread.sleep(1000);}//这里停顿1000是毫秒
               catch(InterruptedException e){e.printStacTrace();}
           }
       }
   }
   public class ThreadJoinDemo{
       public static void main(String[] args){
           ThreadJoin tj1 = new ThreadJoin();
           ThreadJoin tj2 = new ThreadJoin();
           ThreadJoin tj3 = new ThreadJoin();
           tj1.setName("康熙");
           tj2.setName("四阿哥");
           tj3.setName("八阿哥");
           tj1.start();
           try{tj1.join();}//调用join后，只有tj1结束后，后面线程才能获取
           catch(InterruptedException e){e.printStackTrace(); }
           tj2.start();
           tj3.start();
           
           ThreadJoin td1 = new ThreadJoin();
           ThreadJoin td2 = new ThreadJoin();
           td1.setName("关羽");
           td2.setName("张飞");
           //设置主线程为刘备
           Thread.currentThread().setName("刘备");
           //设置守护线程  （当主线程结束后，只剩两个守护线程，虚拟机退出）
           td1.setDaemon(true);
           td2.setDaemon(true);
           td1.start();
           td2.start();
           for(int i=0;i<10;i++){
               System.out.println(Thread.currentThread().getName()+":"+i);
           }
       }
   }

2. 多线程实现方式2实现Runnable接口（定义一个类MyRunnable实现Runnable接口；在MyRunnable类中重写run（）方法；创建Thread类的对象，把MyRunnable对象作为构造方法参数；启动线程）

public class MyRunnable implements Runnable{
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
​
public class MyRunnableDemo{
    public static void main(String[] args){
        //创建MyRunnable类对象
        MyRunnable my = new MyRunnable();
        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        Thread t1 = new Thread(my, "高铁");
        Thread t2 = new Thread(my, "飞机");//相当把MyRunnable当作一个资源，多个线程去使用
        //启动线程
        t1.start();
        t2.start();
    }
}

//多线程实现方式两种：继承Thread类 实现Runnable接口(适合多个相同程序处理同一个资源问题）