2024年大数据最全带你从零学大数据系列之Java篇---第二十章多线程基础(3)，38岁的中年失业者怎么活下去-CSDN博客

本文链接：https://blog.csdn.net/tencentes/article/details/138818534

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // Runnable接口的匿名实现类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out,println("子线程处理的逻辑");
            }
        };
        // 实例化线程对象
        Thread thread = new Thread(runnable);
    }
}

20.3.1.3. 优缺点对比

继承的方式：优点在于可读性比较强，缺点在于不够灵活。如果要定制一个线程，就必须要继承自Thread类，可能会影响原有的继承体系。
接口的方式：优点在于灵活，并且不会影响一个类的继承体系。缺点在于可读性较差。

后面课程中，用的比较多的方式是使用接口的方式。

20.3.2. 线程名字的设置

每一个线程，都有一个名字。如果在实例化线程的时候不去设定名字，那么这个线程会拥有一个默认的名字。

设置线程的名字，使用方法 setName(String name)

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("子线程的逻辑")；
        });
        // 设置线程的名字
        thread.setName("子线程的名字");
    }
}

Thread类对象，在进行实例化的时候，可以同时设置线程的名字。

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Thread thread = new Thread(() -> {}, "线程的名字");
    }
}

如果使用继承Thread类的方式进行的实例化，可以添加一个构造方法，进行实例化对象的同时进行名称的设置。在构造方法中，使用 super(String) 进行父类方法的调用。

/**
 * @Description
 */
public class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    
    @Override
    public void run() {
        System.out.println("子线程的逻辑");
    }
}

设置线程名字，可以使用上述三种方式，但是获取线程线程的名字，只有一个方法，就是 getName()

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Thread thread = new Thread(() -> {}, "线程的名字");
        
        System.out.println(thread.getName());
    }
}

20.3.3. 线程的执行

线程对象刚刚被实例化的时候，线程处于新生态。如果需要让这个线程执行他的任务，需要调用 start() 方法，使线程进入到就绪态，争抢CPU时间片。

注意事项：

使用start()方法，不是run()方法！

使用start方法，会使得线程进入到就绪态，开始争抢CPU时间片，实现并发的任务。如果直接调用run方法，那么任务将会直接在当前线程中执行，并不会实现并发！

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Thread thread = new Thread(() -> {}, "线程的名字");
        thread.start();
    }
}

20.3.4. 线程的礼让

线程礼让，就是是的当前已经抢到CPU资源的正在运行的线程，释放自己持有的CPU资源，回到就绪状态，重新参与CPU时间片的争抢。

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Runnable runnable = () -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + " : " + i);
                if (i == 5) {
                    Thread.yield();
                }
            }
        };
        // 实例化两个线程， 处理的逻辑完全相同
        Thread thread0 = new Thread(runnable, "t0");
        Thread thread1 = new Thread(runnable, "t1");
        
        thread0.start();
        thread1.start();
    }
}

20.3.5. 线程的休眠

线程休眠，就是让当前的线程休眠指定的时间。休眠的线程进入到阻塞状态，直到休眠结束。阻塞的线程，不参与CPU时间片的争抢。

注: 线程休眠的时间单位是毫秒。

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Runnable runnable = () -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + " : " + i);
                try {
                    // 线程休眠
                    Thread.sleep(1000);
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        // 实例化两个线程， 处理的逻辑完全相同
        Thread thread0 = new Thread(runnable, "t0");
        Thread thread1 = new Thread(runnable, "t1");
        
        thread0.start();
        thread1.start();
    }
}

20.3.6. 线程的合并

将一个线程中的任务，合并入到另外一个线程中执行，此时，合并进来的线程有限执行。类似于：插队。

/**
 * @Description
 */
public class Program {
    // 记录余票数量
    static int ticketCount = 100;
    
    public static void main(String[] args) {
        // 循环卖票
	   while (ticketCount > 0) {
           // 票数 -1
	   	  System.out.println("窗口卖出一张票给散客，剩余: " + --ticketCount);
	   	  // 卖出 30 张
	   	  if (ticketCount == 70) {
              // 实例化⼀个 VIP 团体线程
              Thread vip = new Thread(() -> {
                  for (int i = 0; i < 50; i++) {
                      System.out.println("窗口卖出一张票给VIP团队，剩余: " + --ticketCount);
                  }
              });
	   		// 先开启
	   		vip.start();
	   		// 再合并
	   		try {
	   			vip.join();
	    	} catch (InterruptedException e) {
	   			e.printStackTrace();
	    	}
          }
       }
	  Thread thread = new Thread(runnable);
	  thread.start();
    }
}

20.3.7. 线程的优先级设置

设置线程的优先级，可以决定这个线程能够抢到CPU时间片的概率。线程的优先级范围在 [1, 10]，默认的优先级是5。数值越高，优先级越高。但是要注意，并不是优先级高的线程一定能抢到CPU时间片，也不是优先级的线程一定抢不到CPU时间片。线程的优先级只是决定了这个线程能够抢到CPU时间片的概率。即便是优先级最低的线程，依然可以抢到CPU时间片。

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Runnable runnable = () -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
        };
        // 实例化两个线程， 处理的逻辑完全相同
        Thread thread0 = new Thread(runnable, "t0");
        Thread thread1 = new Thread(runnable, "t1");
        
        // 设置线程的优先级， 必须在这个线程启动之前
        thread0.setPriority(1);
        thread1.setPriority(10);
        
        thread0.start();
        thread1.start();
    }
}

20.3.8. 当前线程的获取