多线程并不能提高运行速度，但可以提高运行效率，让cpu的使用率更高。并且，如果多线程有安全问题的处理时，运算效率反而更低。
image.png
**

多线程介绍：

多线程是java中的一个并发的概念：
在计算机的运行中，所有的进程都是同时运行的（cpu会同时调用，之后随机的获取分配）

1.在java程序中也是支持的！
2.在java执行main方法的时候，其实就是执行一个名字叫做main的线程，可以在main线程执行的时候，开启多个其他的线程A,B,C等等，多个线程A,B,C等等都是同时执行的，同时等等cpu的调用，相互抢夺cpu调用自己的时间片段。
3.Thread类是java中的专门用于处理线程的api，是java.lang下的常用类，每一个Thread类的对象，
就代表一个某种状态的线程。

  • java.lang包下的常用的类有:String,System,八大基本类型,Thread…

  • 进程：表示一个个的正在运行的程序

  • 线程：表示一个个正在运行程序中的子进程（线程）
  • 包含关系：一个进程包含多个进程

java中使用Thread类来创建线程

第一种方式：

步骤：

  • 1.指定执行线程的目标：定义一个Thread子类，重写run方法，将相关的逻辑实现，public void run():将需要的逻辑写在里面，该方法相当于线程中的main方法。
  • 2.创建自定义线程的子类对象

  • 3.开启线程操作 - 触发

  • public void start():只要调用了这个方法，线程才会启动，开始执行

Thread中的相关方法：

  • public final String getName():获取线程的名称
  • public final void setName():设置线程的名字
  • public static Thread currentThread():获取当前的线程对象

线程的运行默认是不可控制的，是cpu随机调用，我们只能看到运行的结果。
**

  1. package ThreadDemo1;
  3. /**
  4.  * 自定义线程类
  5.  * 定义一个Thread的子类！
  6.  * 
  7.  * 创建线程的第一种方式：继承Thread类
  8.  */
  9. public class MyThread extends Thread{
  11.     //重写run方法 - 相关的逻辑写进去
  12.     @Override
  13.     public void run(){
  14.         for (int i = 0; i < 50; i++) {
  15.             /*
  16.             this表示当前正在被调用的这个线程
  17.             获取线程的名字是java干的事情（java定义的），我们不管，只要看就行了
  18.              */
  19.             System.out.println(this.getName()+":"+i);
  20.         }
  21.     }
  22. }
  1. package ThreadDemo1;
  3. public class ThreadDemo1 {
  4.     //主线程
  5.     public static void main(String[] args) {
  6.         //创建线程对象 - 用于开启线程
  7.         Thread t0 = new MyThread();
  8.         Thread t1 = new MyThread();
  10.         //开启线程 - 直接运行
  11.         t0.start();
  12.         t1.start();
  13.         System.out.println("===========================");
  14.         //返回一个main线程 - 其实就是main方法的线程
  15.         Thread mainThread = Thread.currentThread();
  16.         System.out.println(mainThread);//Thread[main,5,main]
  17.         for (int i = 0; i < 50; i++) {
  18.             System.out.println(mainThread.getName()+":"+i);
  19.         }
  20.     }
  21. }

第二种方式：实现Runnable接口

  • 1.实现接口，并且要实现run方法
  • 2.在run方法中添加逻辑代码
  • 3.通过start启动线程 ```java package ThreadDemo1;

/**

  • 创建线程的第二种方式： */ public class MyRunnable implements Runnable{

    @Override public void run() {

    1.  //返回当前线程
    2.  Thread thisThread = Thread.currentThread();

    } }

  1. **步骤：**
  3. - 1.指定线程执行的目标：定义Runnable接口，并且实现接口，重写run方法，指定目标逻辑
  4. - 2.通过指定线程执行目标的构造方法创建线程对象
  5.    - public Thread(Runnable target)
  6.    - 1）创建线程，并且执行目标对象
  7.    - 2）通过线程执行目标对象创建线程对象
  8. - 3.开启线程操作（start）
  10. **好处：将任务和线程相分离，耦合度比较低，使用也更加的广泛。**
  11. ```java
  12. package ThreadDemo1;
  14. /**
  15.  * java中使用Thread类来创建线程：语法
  16.  *第二种方式：
  17.  *
  18.  */
  19. public class ThreadDemo2 {
  20.     //主线程
  21.     public static void main(String[] args) {
  22.         //创建线程执行目标
  23.         MyRunnable mr = new MyRunnable();//线程对象 - 任务
  24.         //通过指定线程执行目标的构造函数来创建线程
  25.         Thread thread = new Thread(mr);//线程名称
  26.         thread.setName("jack");
  27.         Thread thread2 = new Thread(mr);//线程名称
  28.         thread.setName("rose");
  30.         //开启线程
  31.         thread.start();
  32.         thread2.start();
  34.     }
  35. }

匿名内部类创建线程 - 实际开发中使用

  • 1.使用匿名内部类创建线程的原理和普通类创建线程原理完全一样。
  • 2.区别在于利用匿名内部类创建线程的写法更加的简洁，使用非常多。 ```java package AnonysThread;

/**

  • 匿名内部类创建线程 - 实际开发中使用 *
  • 1.使用匿名内部类创建线程的原理和普通类创建线程原理完全一样。

  • 2.区别在于利用匿名内部类创建线程的写法更加的简洁，使用非常多。 / public class AnonysThreadDemo { public static void main(String[] args) {

    1.  //方式一：使用匿名内部类创建线程的子类对象
    2.  Thread t1 = new Thread(){
    3.      @Override
    4.      public void run(){
    5.          System.out.println("我很好");
    6.      }
    7.  };
    8.  t1.start();
    10.  System.out.println("-----------------------------------------------");
    12.  //使用匿名内部类，创建线程的匿名子类对象，并且启动线程
    13.  new Thread(){
    14.      @Override
    15.      public void run(){
    16.          System.out.println("还记得上次你我身旁的样子");
    17.      }
    18.  }.start();
    20.  //方式二：使用匿名内部类的方式，创建执行目标类的对象
    21.  Runnable r = new Runnable(){
    22.      @Override
    23.      public void run(){
    24.          System.out.println("她来了然后他死了");
    25.      }
    26.  };
    27.  //传入到构造函数
    28.  Thread t2 = new Thread(r);
    29.  t2.start();
    31.  System.out.println("==========================================");
    33.  //组合写法 - 精简写法
    34.  new Thread(new Runnable() {
    35.      @Override
    36.      public void run() {
    37.          System.out.println("往事只能后悔");
    38.      }
    39.  }).start();
    41.  //t3的普通写法
    42.  Thread t3 = new Thread(new Runnable() {
    43.      @Override
    44.      public void run() {
    45.          System.out.println("往事只能后悔");
    46.      }
    47.  });
    48.  t3.start();

    } }

```