一 java------线程---线程的创建_创建子类rabbit继承父类,重写名称属性以及run()方法,打印小兔子跑的很快-CSDN博客

本文链接：https://blog.csdn.net/m15231417197/article/details/83028415

线程一些小知识的整理

一：线程的创建（继承Thread类方式）
需求：龟兔赛跑----创建两个线程，一个线程命名为兔子Rabbit 一个线程名称为乌龟Tortoies
技能：创建线程并启动线程
1.创建线程的方式，有两种，一种是继承Thread类，一种是实现Runnable接口
2.继承Thread类----Thread类
   2.1 Thread类的定义
       线程是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。
   2.2 关于继承关系，如果一个子类继承了Thread类，那么此子类也就是一个线程类了！所以创建的子类对象，也就是线程对象。
       分析：龙生龙，凤生凤，老鼠天生会打洞！
       模式：
           class 子类名称 extends Thread {
              //重写run()方法
              public void run(){
              // 此方法时线程的主体，把核心代码放入到此方法中！
                 执行代码
                }

            }
    2.3 实现Runnable接口---此接口只有一个抽象方法 run()
          发现：如果一个子类实现一个接口，此接口如果存在抽象方法，则子类必须重写！
          发现：Thread类和Runnable直接的关系-----实现关系 Thread类实现了Runnable接口
                Thread类的构造方法----两个比较重要的
                 　                     public Thread(Runnable r);
                public Thread (Runnable r, String name)
          模式：
             class 子类名称 implements Runnable {
                //重写run()方法
                public void run(){
                   // 此方法时线程的主体，把核心代码放入到此方法中！
                   执行代码
                }

            }

    3.线程的启动，是调用run()方法还是start()方法？
        3.1 如果创建的线程对象，调用的是run()方法，那么只会把run方法看成是一个普通方法进行执行。
            所以，不要直接调用run()方法！
        3.2 如果调用的是start()方法，根据API的解释，JVM会在后台自动的去调用run()方法
            所以,启动线程是调用start()方法

        3.3 发现：在兔子线程当中，启动之后调用run()，如果run()方法里面嵌套了一个while死循环
                 兔子线程一直在执行-----乌龟线程有机会运行吗？不会执行的
        3.4 main方法也是一个线程，而且是主线程
代码区：
public class Rabbit extends Thread{

//为什么不是属性而是使用构造方法呢？因为在父类Thread类当中有一个构造方法，public Thread(String name)
public Rabbit(){
}
public Rabbit(String name){
  super(name);
}
//重写run方法
public void run(){
  //既然说run方法是线程的主题，把核心代码放入到此方法中！
  while(true){
   System.out.println(Thread.currentThread().getName()+"------领先了");
  }
}
}
public class Tortoies extends Thread{
//构造方法
public Tortoies(){
}
    public Tortoies(String name){
  super(name);
}
public void run(){
  while(true){
   //把核心代码放入到此方法中
   System.out.println(Thread.currentThread().getName()+"------领先了");
  }
}
}
public class ThreadTest1 {
public static void main(String[] args) {
  //开始创建线程
    Rabbit r = new Rabbit();
    Tortoies t = new Tortoies();
  //为线程命名
    /**
     * setName()
     * getName()
     * Thread.currentThread()
     * 都是Thread类的方法，子类通过继承可以调用
     */
    r.setName("兔子");
    t.setName("乌龟");
  //启动线程
    r.start();
    t.start();
}
}
二：线程的创建（实现Runnable接口方式）
需求：大运动会上，运动员进行赛跑----男超人和女超人
技能：创建线程并启动线程----实现Runnable接口
问题1：启动线程是调用start方法，那么Runnable接口只有一个run()方法，没有start方法，怎么启动线程？
解决1：谁有start()方法？---Thread类里面存在一个start方法 ---- 可以借助Thread类
        发现： Thread类的构造方法
              public Thread(Runnable r)
             public Thread(Runnable r,String name)

问题2：创建多个线程，由于并发机制，线程的启动以及运行，显得毫无规律
原因2：线程的随机性太强---- 体现出各个线程在抢CPU资源，如果那个线程抢到了那么那个线程执行，可能有的线程一次也不会抢到。
解决2：可以使用同步锁
问题3：发现创建线程的方式有两种，两者创建线程的区别？
        继承Thread类
           优点：简单
           缺点：由于单继承的线程，无法继承其他的类
        实现Runnable接口
           优点：可以继承其它类，多线程可共享同一个Runnable对象
代码区：
public class SuperMan extends Object implements Runnable {
// String name;
//构造方法以及属性，写还是不写？不写啦，原因如下：
/*
* 1.如果一个类，没有定义任何的构造方法，则JVM会默认的配一个孔参构造方法
* 2.创建有参构造方法
*     2.1 通过父类获取---super(name),发现：SuperMan子类实现的是Runnable接口，不是Thread类
*     2.2 因为Thread类里面的构造方法---public Thread(Runnable r,String name)
*/
@Override
public void run() {
  //run方法---线程的主题，把核心代码放入到此方法中
//  while(true){
  for(int i=1;i<=20;i++){
   System.out.println(Thread.currentThread().getName()+"领先了......");
  }
}
}
public class SuperWoman implements Runnable {
@Override
public void run() {
//  while(true){
  for(int i=1;i<=20;i++){
   System.out.println(Thread.currentThread().getName()+"领先了");
  }
}
}
public class ThreadTest2 {
public static void main(String[] args) {
  //1.创建Runnable接口对象，目的：创建线程对象
      Runnable r1 = new SuperMan();
//      Runnable r2 = new SuperWoman();
  //2.如果实现Runnable接口，来创建线程对象，则离不开Thread类
      Thread t1 = new Thread(r1,"高宇");
      Thread t2 = new Thread(r1,"王梦凡");
  //3.启动线程
      t1.start();
      t2.start();
}
}