Java多线程的学习与总结

1.1进程

进程：是正运行的程序

1. 是系统进行资源分配和调用的独立单位
2. 每一个进程都有它自己的内存空间的系统资源

1.2线程

线程：是进程中的单个顺序控制流，是一条执行路径

1. 单线程：一个进程如果只有一条执行路径，则称为单线程程序
2. 多线程：一个进程如果有多条执行路径，则称为多条线程

1.3多线程的实现

方式1：继承Thread类

1. 定义一个类MyThread继承Thread类
2. 创MyThread类中重写run(()方法
3. 创建Mytread类的对象
4. 启动多线程

两个问题：

1. 为什么要重写run方法:        因为run()是用来封装被线程执行的代码
2. run()放和start方法的区别run()：  封装线程执行的代码，直接调用，相当于普通方法的调用
3. start():启动线程;然后由JVM虚拟机调用此线程的run()方法

   public class MyThrean1 extends Thread {
       @Override
       public void run() {
           for (int i = 0; i <=300; i++) {
               System.out.println(i);
           }
       }
   
   public class MyThreanDemo1 {
       public static void main(String[] args) {
           MyThrean1 my1=new MyThrean1();
           MyThrean1 my2=new MyThrean1();
   
           my1.start();
           my2.start();
       }
   }

1.4设置和获取线程的名称

Thread类中设置和获取线程名称的方法

1. void setName(String name):将此线程的名称更改为等于参数name
2. String getName():返回此线程的名称
3. 通过构造方法也可以设置线程名称

如何获取main()方法所在的线程名称？

Public staitc Thread currentThread():返回对当前正在执行的线程对象的引用

/**
 * Thread类中设置和获取线程名称的方法:

 * String getName():返回此线程的名称
 */


public class MyThread extends Thread {

    public MyThread() {
    }

    /**
     * public Thread(String name) {
     * init(null, null, name, 0);
     * }
     *
     * @param name
     */
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

/**
 * private String name;
 * <p>
 * public Thread(){//构造方法
 * this(null,null,"Thread-"+nextThreadNu(),0);
 * }
 * <p>
 * public Thread(String name) {
 * init(null, null, name, 0);
 * }
 * <p>
 * public Thread(ThreadGroup group,Runnable target,String name
 * ,long stackSize){
 * this(gtoup,target,name,stackSize,null,true);
 * }
 * <p>
 * private Thread(ThreadGroup g,Runnable target,String name,
 * Long stackSize,AccessControlContext acc,
 * boolean inheritThreadLocals){
 * this.name=name;
 * }
 * <p>
 * private static int threadInitNumber;//0,1
 * private staitc synchronized int nextThreadNum(){
 * retrun threadInitNumber++;//0
 * }
 */

1.5线程调度

线程有两种调度模型

1. 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
2. 抢占式调度模型：优先让优先级搞的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级搞的线程获取的CPU的时间片相对多一些。

Java使用的是抢占式模型调度

1. 假如计算机只有一个CPU，那么CPU在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令，所以说多线程程序的执行是随机性，因为谁抢到CPU的使用权是不一定的。

Thread类中设置和获取线程优先级的方法：

1. Public final int getPriority():返回此线程的优先级
2. Public final void setPriority(int new Priority):更改此线程的优先级

线程默认优先级是5，线程优先级的范围是：1-10

1. 线程优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果

   
   
   public class ThreadPriority extends Thread {
      
       @Override
       public void run() {
           for (int i = 0; i <= 100; i++) {
               System.out.println(getName()+"----"+i);
           }
       }
   }
   
   
   
   
   public class ThreadPoriorityDemo {
       /**
        * Thread类中设置和获取线程优先级的方法：
        * Public final int getPriority():返回此线程的优先级
        * Public final void setPriority(int new Priority):更改此线程的优先级
        * @param args
        */
       public static void main(String[] args) {
           ThreadPriority tp1=new ThreadPriority();
           ThreadPriority tp2=new ThreadPriority();
           ThreadPriority tp3=new ThreadPriority();
   
           tp1.setName("高铁");
           tp2.setName("飞机");
           tp3.setName("地铁");
           /**Public