多线程（笔记）

八.多线程

（1）基本概念：程序，进程，线程

（2）线程的创建和使用

/**
 * 多线程的创建：
 * 方式一：继承于Thread类
 *  1.创建一个继承于Thread类的子类
 *  2.重写Thread类中的run方法-->将此线程执行的操作声明在run()中
 *  3.创建Thread类的子类的对象
 *  4.通过此对象调用start()方法
 *    start()方法的作用：
 *      ①：启动当前线程
 *      ②：调用当前线程的run()
 *  例子：遍历100以内所有的偶数
 */
//1.创建一个继承于Thread类的子类
class MyThread extends Thread{
//    2.重写Thread类中的run方法
    @Override
    public void run() {
//    遍历100以内所有的偶数
    System.out.println("100以内的偶数为:");
        for(int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args){
//        3.创建Thread类的子类的对象
        MyThread myThread1 = new MyThread();
//        4.通过此对象调用start()方法
        myThread1.start();

        //问题一：不能直接调用run()方法的方式启动线程
//          myThread.run();
        //问题二：再启动一个线程，遍历100以内的偶数，不可以还让已经start()的线程去执行。会报IllegalThreadStateException
        //新建线程来调用
        MyThread myThread2 = new MyThread();
        myThread2.start();
        //如下操作仍在main线程中执行

        for(int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(i+"****");
            }
        }
    }
}

/**
 * 创建多线程的方式二：实现Runnable接口
 * 1.创建了一个实现了Runnable接口的类
 * 2.实现类去实现Runnable中的抽象方法：run()
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.通过Thread类的对象去调用start()方法
 * 
 * @date: 2022/4/15 16:43
 * @author: ccw
 */
//1.创建了一个实现了Runnable接口的类
class MyThread implements Runnable{
//2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
}


public class ThreadTest1 {
    public static void main(String[] args){
        //3.创建实现类的对象
        MyThread myThread=new MyThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1=new Thread(myThread);
        //5.通过Thread类的对象去调用start()方法
        t1.start();
        //再创建一个线程，无需再执行第三步
        Thread t2=new Thread(myThread);
        t2.start();
    }

}

两种创建方式的比较：

开发中，优先选择：实现Runnable接口的方式
原因：1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程有共享数据的情况。

相同点：两种方式都需要重写run()方法，将线程要执行的逻辑声明在run()中。

（3）创建和使用线程练习：

/**
 * 练习：创建两个分线程：其中一个遍历100以内的偶数，另一个遍历100以内的奇数
 *
 */



public class ThreadDemo {
    public static void main(String[] args) {
//        MyThread1 myThread1=new MyThread1();
//        myThread1.start();
//        MyThread2 myThread2=new MyThread2();
//        myThread2.start();

        //创建Thread类的匿名子类的方式
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 0) {
                        System.out.println(i);
                    }
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 1) {
                        System.out.println(i);
                    }
                }
            }
        }.start();
    }
}

//    class MyThread1 extends Thread {
//        @Override
//        public void run() {
//            for (int i = 0; i < 100; i++) {
//                if (i % 2 == 0) {
//                    System.out.println(i);
//                }
//            }
//        }
//    }
//
//    class MyThread2 extends Thread {
//        @Override
//        public void run() {
//            for (int i = 0; i < 100; i++) {
//                if (i % 2 == 1) {
//                    System.out.println(i);
//                }
//            }
//        }
//    }
//}

（4）Thread中常用的方法：

• 1.start():启动当前线程，调用当前线程的run()。

• 2.run():通常需要重写Thread类中的此方法，将创建的线程所要执行的步骤卸载run()方法中

• 3.currentThread():静态方法，返回执行当前代码的线程

• 4.getName():获取当前线程的名字

• 5.setName():设置当前线程的名字

• 6.yield():释放当前cpu的执行权

• 7.join():在线程a中调用线程b的join方法，此时线程a进入阻塞状态，直到线程b执行完以后，线程a才结束阻塞状态

• 8.stop():已过时。当执行此方法时，强制结束当前线程。

• 9.sleep(long milliTime):让当前线程"睡眠"指定的milliTime毫秒，在指定的时间内，当前线程是阻塞状态

• 10.isAlive():判断当前线程是否存活

  /**
   * 测试Thread中的常用方法：
   * 1.start():启动当前线程，调用当前线程的run()。
   * 2.run():通常需要重写Thread类中的此方法，将创建的线程所要执行的步骤卸载run()方法中
   * 3.currentThread():静态方法，返回执行当前代码的线程
   * 4.getName():获取当前线程的名字
   * 5.setName():设置当前线程的名字
   * 6.yield():释放当前cpu的执行权
   * 7.join():在线程a中调用线程b的join方法，此时线程a进入阻塞状态，直到线程b执行完以后，线程a才结束阻塞状态
   * 8.stop():已过时。当执行此方法时，强制结束当前线程。
   * 9.sleep(long milliTime):让当前线程"睡眠"指定的milliTime毫秒，在指定的时间内，当前线程是阻塞状态
   * 10.isAlive():判断当前线程是否存活
   */
  class HelloThread extends Thread{
      @Override
      public void run() {
          for(int i=0;i<100;i++){
              if(i%2==0){
  
                  try {
                      sleep(1000);//单位:毫秒
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  System.out.println(Thread.currentThread().getName()+":"+i);
              }
  
  //          if(i%20==0){
  //                this.yield();//方法中调用自己的方法，this可以省略
  //            }
          }
      }
      //方法二：通过构造器来为线程命名
      public HelloThread(String name) {
          super(name);
      }
  }
  
  public class ThreadMethodsTest {
      public static void main(String[] args){
          HelloThread helloThread=new HelloThread("Thread:1");
  
  
          //方法一：在start之前命名
  //        helloThread.setName("线程一");
          helloThread.start();
  
          //给主线程命名
          Thread.currentThread().setName("主线程");
  
          for(int i=0;i<100;i++){
              if(i%2==0){
                  System.out.println(Thread.currentThread().getName()+":"+i);
              }
  //            join方法演示:
              if(i==20){
                  try {
                      helloThread.join();//helloThread线程进入，主线程阻塞
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }
      }
  
  
  }
  

（5）线程优先级

（6）线程的生命周期

（7）线程的同步与安全

/**
 * 例子：创建三个c窗口卖票，总票数为100张
 * 1.问题：卖票过程中出现重票，错票————>线程的安全问题
 * 2.原因：当某个线程执行操作车票的过程中，尚未操作完成，其他线程参与进来，也操作了车票
 * 3.解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。
 *      直到线程a操作完成ticket时，线程才能操作ticket，这种情况即使a出现了阻塞，也不能改变
 *4.在Java中使用线程的同步机制来解决线程的安全问题。
 * 方式一：同步代码块
 * 关键字：synchronized(同步监视器){
 *     // 需要被同步的代码
 * }
 * 说明：1.操作共享数据的代码，即为需要被同步的代码
 *      2.共享数据：多个线程共同操作的变量。比如ticket
 *      3.同步监视器：俗称 ：锁。任何一个类的对象，都可以充当锁。
 *        要求：多个线程要共用同一把锁
 *
 *
 * 5.同步的方式解决了线程的安全问题———>好处
 *   操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的问题，效率低。
 *
 */
//实现Runnable接口的线程同步使用方法
class Window implements Runnable{
    private  int ticket=100;
    //Object object=new Object();
    @Override
    public void run() {
        while(true){
            synchronized (this){//可以使用this来充当Window的唯一对象  方式二：synchronized (object){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"卖票，票号为:"+ticket);
                ticket--;
            }else{
                break;
            }
        }
        }
    }
}

public class WindowTest {
    public static void main(String[] args){
        Window window=new Window();
        //Thread三个对象调用Window的同一个属性，属性无需static
        Thread t1=new Thread(window);
        t1.setName("窗口1");
        t1.start();
        Thread t2=new Thread(window);
        t2.setName("窗口2");
        t2.start();
        Thread t3=new Thread(window);
        t3.setName("窗口3");
        t3.start();
    }
}



//继承Thread时线程的同步使用方法：
class MyThreadTest extends Thread  {
    private  int ticket=100;
    static Object obj=new Object();//用static保着三个造对象时用的同一个监视器

    @Override
    public void run() {
        synchronized(obj){//这里用this是错误的，这里this代表m1，m2，m3三个对象
            while(true){
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+"卖票，票号为"+ticket);
                    ticket--;
                }
            }
        }
    }
}

public class WindowTest2{
    public static void main(String[] args){
        MyThreadTest m1=new MyThreadTest();
        MyThreadTest m2=new MyThreadTest();
        MyThreadTest m3=new MyThreadTest();

        m1.setName("窗口1");
        m2.setName("窗口2");
        m3.setName("窗口3");

        m1.start();
        m2.start();
        m3.start();

    }
}

/** 方式二：同步方法
 * 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
 *
 * 使用同步方法来解决实现Runnable接口的线程安全问题
 * 
 */
class Window3 implements Runnable{
    private  int ticket=100;
    @Override
    public void run() {
        while (true) {
            show();
        }
    }
        private synchronized void show () {//同步监视器：this
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖票，票号为:" + ticket);
                ticket--;
            }
        }
    }


public class WindowTest3 {
    public static void main(String[] args){
        Window3 window=new Window3();
        //Thread三个对象调用Window的同一个属性，属性无需static
        Thread t1=new Thread(window);
        t1.setName("窗口1");
        t1.start();
        Thread t2=new Thread(window);
        t2.setName("窗口2");
        t2.start();
        Thread t3=new Thread(window);
        t3.setName("窗口3");
        t3.start();
    }
}


/**
 * 使用同步方法解决继承Thread方式中的线程问题
 * 
 */
class Window4 extends Thread  {
    private  static int ticket=100;

    @Override
    public void run() {
            while(true){
                show();
            }
    }
//    private  synchronized void show(){//同步监视器：w1,w2,w3     需要将方法改为static
    private static synchronized void show(){//同步监视器：Window4.class
        if(ticket>0){
            System.out.println(Thread.currentThread().getName()+"卖票，票号为"+ticket);
            ticket--;
        }
    }
}

public class WindowTest4{
    public static void main(String[] args){
        Window4 w1=new Window4();
        Window4 w2=new Window4();
        Window4 w3=new Window4();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();

    }
}

/**
 * 解决线程问题的方法三：Lock锁------jdk5.0新增
 * 步骤：
 *  1.实例化ReentrantLock
 *  2.调用锁定的方法：lock()
 *  3.调用解锁的方法：unlock()
 * 
 * @date: 2022/4/21 21:58
 * @author: ccw
 */
public class LockTest {
    public static void main(String[] args){
        Window w=new Window();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window implements Runnable{
    private int ticket=100;
    //1.实例化ReentrantLock
    private ReentrantLock lock=new ReentrantLock();//括号内可为ture，默认false。ture表示等待的每个线程都按顺序被执行，而非抢线程

    @Override
    public void run() {
        while(true){
            try {
                //2.调用锁定的方法：lock()
                lock.lock();

                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+"卖票，票号为"+ticket);
                }else{
                    break;
                }
            }finally {
                //3.调用解锁的方法：unlock()
                lock.unlock();
            }

        }
    }
}

synchronized与Lock的异同：

相同：二者都可以解决线程安全问题

不同：synchronized机制在执行完相应的同步代码以后，自动地释放同步监视器
Lock需要手动的启动同步（lock（）），同时结束也需要手动实现（（unlock)）

三种安全方式优先使用顺序：Lock---->同步代码块---->同步方法

（8）改写懒汉式，使得线程安全

/**
 * 使用同步机制改写单例模式懒汉式，使得其线程安全
 * 
 * @date: 2022/4/21 15:55
 * @author: ccw
 */

public class BankTest {

}

class Bank{
    private Bank() {
    }

    private static Bank instance=null;

    private static Bank getInstance(){
        //方式一：效率稍差
//        synchronized (Bank.class) {
//            if(instance == null){
//                instance=new Bank();
//            }
//        }
//        return instance;
        //方式二：效率更高
        if(instance == null){
            synchronized (Bank.class) {
                if(instance == null){
                    instance=new Bank();
                }
            }
        }
       return instance;
    }
}

（9）线程的死锁

/**
 * 演示线程的死锁问题
 *
 * 说明：
 * 1.出现死锁后，不会出现异常，不会出现提示，只是线程都处于阻塞状态，无法继续
 * 2.我们使用同步时，要避免出现死锁
 * 解决方法：
 * 1.专门的算法，原则
 * 2.尽量减少同步资源的定义
 * 3.尽量避免嵌套同步
 *
 * @date: 2022/4/21 16:21
 * @author: ccw
 */
public class ThreadTest {
    public static void main(String[] args){
        StringBuffer s1=new StringBuffer();
        StringBuffer s2=new StringBuffer();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1){

                    s1.append("a");
                    s2.append("1");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");

                        System.out.println(s1);
                        System.out.println(s2);

                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){

                    s1.append("c");
                    s2.append("3");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);

                    }
                }
            }
        }).start();

    }
}

（9）线程的通信

/**
 * 线程通信的例子：
 * 使用两个线程打印1-100。线程1,线程2交替打印
 *
 * 三个方法：
 * wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
 * notify():一旦执行此方法，就会唤醒被wait的一个线程，如果多个线程被wait，就唤醒优先级最高的那个
 * notifyAll():一旦执行此方法，就会唤醒所有被wait的线程
 *
 * 注意点：
 * 1.wait()，notify()，notifyAll()三个方法使用时必须使用在同步代码块或同步方法中
 * 2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器
 * 3.wait()，notify()，notifyAll()三个方法是定义在object类当中
 *
 * @date: 2022/4/22 12:05
 * @author: ccw
 */
public class ThreadCommunicationTest {
    public static void main(String[] args){
        Number n=new Number();

        Thread t1=new Thread(n);
        Thread t2=new Thread(n);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();

    }
}

class Number implements Runnable{
    private int num=1;
    //打印1-100
    @Override
    public void run() {
        while(true){
            {
                synchronized (this) {

                    notify();


                    try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                    if(num<=100){
                        System.out.println(Thread.currentThread().getName()+":"+num);
                        num++;
                        //使得调用wait()方法的线程暂时进入阻塞状态
                        try {
                            wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                    }else {
                        break;
                    }
                }
            }

        }
    }
}

（10）JDK5.0新增线程创建方式

//1.创建一个实现了Callable接口的实现类
class NumThread implements Callable{
    //遍历所有偶数，并且返回所有偶数的和
    //2，实现call()方法，将此线程要执行的操作声明在call()方法中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for(int i = 0;i <= 100;i++){
            if(i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;//自动装箱（无需返回值，return null即可）
    }
}



public class ThreadNew {
    public static void main(String[] args){
        //3.创建Callable接口实现类的对象
        NumThread numThread=new NumThread();

        //4.将此Callable接口实现类的对象作为传递到FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);

        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //获取Callable中call方法的返回值

            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();

            System.out.println("总和为"+sum);
        } catch (InterruptedException e) {
            e.printStackTrace(); 
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

/**
 * 创建线程的方式四：使用线程池
 *
 * @author: ccw
 * @date: 2022/4/23 16:03
 */
class NumberThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i < 100;i++){
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args){
        //1.提供指定数量的线程的线程池(相当于造线程池)
        ExecutorService service = Executors.newFixedThreadPool(10);
        
        //2.执行指定线程的操作,需要提供实现Runnable接口或Callable接口实现类的对象
        //传入参数（对象）目的是为了知道该执行哪个类中的run方法
        service.execute(new NumberThread());//适合使用于Runnable
//        service.submit();//适合适用于Callable

        //关闭线程池
        service.shutdown();
    }
}