Java_多线程

1.知识点：

1.介绍多线程
2.线程安全

2.知识点的运用：

1.多线程的作用：

• 发挥多核CPU的优势，充分利用CPU资源

• 防止线程阻塞

• 便于建模
  2.线程的生命周期及5种基本状态：

• 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

• 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

• 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

• 阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：
  1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
  2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
  3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

• 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

image.png
image.png

3.创建线程的方式:
一般就是两种：

1）继承Thread类：定义一个继承Thread的类，在类中实现run方法
例：

//创建两个线程，任务都是打印 1 - 100
public class MyClass {
    static TestThread thread2;
    public static void main(String[] args){

        //开启任务
        TestThread thread = new TestThread();
        thread.setName("子线程1");
        thread.start();

        thread2 = new TestThread();
        thread2.setName("子线程2");
        thread2.start();
    }
}

//自定义一个类，继承Thread并实现run方法
class TestThread extends Thread{
    //实现run方法：方法里面就是具体需要执行的代码
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        for (int i = 0; i < 100; i++) {
            System.out.println(name + ":" + i + " ");
            if (this != MyClass.thread2) {
                if (i == 10) {
                    try {
                        MyClass.thread2.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        super.run();
    }
}

2）实现Runnable接口，并实现run方法：

• 1.创建一个任务 ：创建一个类实现Runnable接口
• 2.使用Thread为这个任务分配线程
• 3.开启任务
  例：

//在主函数中
//创建一个线程，任务是打印 1 - 100
        //创建一个任务:创建一个类实现Runnable接口
        yk pt = new yk();
        //使用Thread为这个任务分配线程
        Thread t = new Thread(pt);
        //开启任务
        t.start();
        t.setName("子线程1");

//创建一个类，实现Runnable接口
class yk implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " +  i);
        }
    }
}

4.start()方法和run()方法的区别：

调用start()方法，不同线程的run()方法里面的代码交替执行。调用run()方法，代码是同步执行的，必须等待一个线程的run()方法里面的代码全部执行完毕之后，另外一个线程才可以执行其run()方法里面的代码。
5.什么是线程安全：
我认为：
在多线程下执行和在单线程下执行结果都是一样的，那么代码就是线程安全的。
6.如何在两个线程之间共享数据
可以通过在线程之间共享对象，然后通过wait/notify/notifyAll、await/signal/signalAll进行唤起和等待。
例：
用两个线程合作打印 0 - 100

public class MyClass {
    public static void main(String[] args){

        Ticket ticket = new Ticket("重庆");
        Thread t1 = new Thread(ticket);
        t1.start();

        Ticket ticket2 = new Ticket("上海");
        Thread t2 = new Thread(ticket2);
        t2.start();
    }
}
//创建一个类，实现Runnable接口
class Ticket implements Runnable {
    //定义所有车票的数量
    public static int num = 100;
    String name;

    public Ticket(String name) {
        this.name = name;
    }
    //创建一个共享对象
    static final Object object = new Object();
    public void run() {
        for (int i = 1; i <= 100; i++) {
            synchronized (object) {
                if (num > 0) {
                    System.out.println(name + "出票:" + num);
                    num--;
                    try {
                        // 通知其他线程执行
                        object.notify();
                        //当前线程等待
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }

7.sleep方法和wait方法的区别:
sleep方法和wait方法都可以用来放弃CPU一定的时间，不同点在于如果线程持有某个对象的监视器，sleep方法不会放弃这个对象的监视器，wait方法会放弃这个对象的监视器
8.synchronized和ReentrantLock：
1）synchronized是Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

• synchronized代码块，被修饰的代码成为同步语句块，其作用的范围是调用这个代码块的对象，
• synchronized方法，被修饰的方法成为同步方法，其作用范围是整个方法，作用对象是调用这个方法的对象。
  2）ReentrantLock 互斥锁，在同一时间只能被一个线程所占有，在被持有后并未释放之前，其他线程若想获得该锁只能等待或放弃。
  ReentrantLock 互斥锁是可重入锁，即某一线程可多次获得该锁。

public class Test {
  public static void main(String[] var0) {
    Counter counter = new Counter();
    // 注：myThread1 和 myThread2 是调用同一个对象 counter
    MyThread myThread1 = new MyThread(counter);
    MyThread myThread2 = new MyThread(counter);
    myThread1.start();
    myThread2.start();
  }

  private static class Counter {
    private ReentrantLock mReentrantLock = new ReentrantLock();
    public void count() {
      mReentrantLock.lock();
      try {
        for (int i = 0; i < 6; i++) {
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        }
      } finally {
          // 必须在 finally 释放锁
        mReentrantLock.unlock();
      }
    }
  }
 //定义一个类，继承Thread 
  private static class MyThread extends Thread {
    private Counter mCounter;
    public MyThread(Counter counter) {
      mCounter = counter;
    }
    @Override
    public void run() {
      super.run();
      mCounter.count();
    }
  }
}

9.常用的方法：

• 1.join:让当前的线程阻塞，等join的线程执行完之后再执行
• 2.setName getName 设置、获取线程名称
• 3.currentThread：获取当前运行的线程对象
• 4.start：开启线程