Thread线程

创建多线程的方式

第一种：创建Thread类的子类

• java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类

• 实现步骤：

  1. 创建一个Thread类的子类
  2. 在Thread的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么）
  3. 创建一个Thread类的子类对象
  4. 调用Thread类中的方法start方法，开启新的线程，执行run方法
     • void start()；使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

• 多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。

第二种：实现Runnable接口

• Java.lang.Runnable

  • Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。

• Java.lang.Thread的构造方法：

  • Thread(Runnable target)；分配新的 Thread 对象。
  • Thread(Runnable target, String name)；分配新的 Thread 对象。

• 实现步骤：

  1. 创建一个Runnable接口的实现类
  2. 在实现类中重写Runnable接口的run方法，设置线程任务
  3. 创建一个Runnable接口的实现对象
  4. 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
  5. 调用Thread类中的start方法，开启新的线程，执行run方法

• 实现Runnable接口创建多线程的好处：

  1. 避免了单线程的局限性
     • 一个类只能继承一个类，类继承了Thread类就不能继承其他类
     • 实现了Runnable接口还可以继承其他类实现其他接口
  2. 增强了程序的扩展性，降低了程序的耦合性
     • 实现Runnable接口的方式，把设置线程任务和开启新的线程进行了分离
     • 实现类中，重写了run方法，用来设置线程任务
     • 创建Thread类对象，调用start方法，用来开启新的线程

• 匿名内部类实现线程创建

  • 可以简化代码，把子类继承父类，重写父类的方法，创建子类对象合成一步完成，或者把实现类实现类接口，重写接口中的方法，创建实现类对象合成一步完成

  • 格式：

    new 父类/接口(){
        重写方法
    }
    
    //线程的父类是Thread
    new Thread() {
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName() + "  " + i);
            }
        }
    }.start();
    
    //线程的接口Runnable
    new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName() + "  " + i);
            }
        }
    }).start();

获取线程的名称

• 获取线程的名称：

  1. 使用Thread类中的方法getName()；
     • String getName()；返回该线程的名称。
  2. 可以先获取到当前正在执行的线程，再使用线程中的方法getName()获取线程名称
     • static Thread currentThread()；返回对当前正在执行的线程对象的引用。

• 线程的名称：

  • 主线程：main
  • 子线程：Thread-0，Thread-1，Thread-2….

暂停线程

public static void sleep(long millis, int nanos)； 在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠(暂停执行)

• 此操作受到系统计时器和调度程序精度和准确性的影响。
• 注意：毫秒数结束后，线程继续执行

多线程内存图解

多线程原理

线程不安全的解决方案

第一种：使用同步代码块

• 格式：

  synchronized (锁对象){
      可能会出现线程安全问题的代码（访问了共享数据的代码）
  }

• 注意：

  1. 同步代码块中的锁对象可以是任意的对象
  2. 但是必须保证多个线程使用的锁对象是同一个
  3. 锁对象的作用：把同步代码块锁住，只让一个线程在同步代码块中执行

第二种：使用同步方法

• 使用步骤：

  1. 把访问了共享数据的方法抽取出来，放到一个方法中
  2. 在方法上添加一个修饰符synchronized

• 格式：

  修饰符 synchronized 返回值类型 方法名（参数列表）{
      可能会出现线程安全问题的代码（访问了共享数据的代码）
  }

第三种：Lock锁

• java.util.concurrent.locks.lock接口

• Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

• Lock接口中的常用方法：

  • void lock()；获取锁。
  • void unlock()；释放锁。

• java.util.concurrent.locks.ReentrantLock implements Lock接口

• 使用步骤：

  1. 在成员位置创建一个ReentrantLock对象
  2. 在可能会出现线程安全问题的代码前调用Lock接口中的方法lock()获取锁
  3. 在可能会出现线程安全问题的代码后调用Lock接口中的方法unlock()释放锁

线程池

• 线程池：JDK1.5之后提供的

• java.util.concurrent.Executors：线程池的工厂类，用来生产线程池

• Executors类中的静态方法：

  • static ExecutorService newFixedThreadPool(int nThreads)；创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
    • 参数：
      • int nThreads：创建线程池中包含的线程数量
    • 返回值：
      • ExecutorService接口，返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口接收

• java.util.concurrent.ExecutorService：线程池接口

• 用来从线程池中获取线程，调用start方法执行线程任务：

  • Future<?> submit(Runnable task)；提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。

• 关闭销毁线程池的方法：

  • void shutdown()；启动一次顺序关闭，执行以前提交的任务，但不接受新任务。

• 线程池的使用步骤：

  1. 使用线程池工厂类Executors里边的静态方法newFixedThreadPool生产一个指定线程数量的线程池
  2. 创建一个类，实现Runnable接口，重写run方法，设置线程任务
  3. 调用ExecutorService中的方法submit传递线程任务，开启线程，执行run方法

线程池类似原理