创建两个分线程，干不同的事情

    1. package com.codeday22.demo01;
    3. /**
    4.  * 创建两个线程，一个遍历100内偶数，另外一个遍历100内奇数
    5.  *
    6.  */
    8. public class ThreadDemo {
    9.     public static void main(String[] args) {
    10. //        MyThread1 t1 = new MyThread1();
    11. //        t1.start();
    12. //
    13. //        MyThread2 t2 = new MyThread2();
    14. //        t2.start();
    16.         // 也可以创建Thread的匿名子类
    17.         new Thread(() -> {
    18.             for (int i = 0; i < 100; i++) {
    19.                 if (i % 2 == 0){
    20.                     System.out.println(Thread.currentThread().getName() + ":" + i);
    21.                 }
    22.             }
    23.         }).start();
    25.         new Thread(){
    26.             @Override
    27.             public void run() {
    28.                 for (int i = 0; i < 100; i++) {
    29.                     if (i % 2 == 1){
    30.                         System.out.println(Thread.currentThread().getName() + ":" + i);
    31.                     }
    32.                 }
    33.             }
    34.         }.start();
    35.     }
    36. }
    38. //class MyThread1 extends Thread{
    39. //        @Override
    40. //        public void run() {
    41. //            for (int i = 0; i < 100; i++) {
    42. //                if (i % 2 == 0){
    43. //                    System.out.println(MyThread1.currentThread().getName() + ":" + i);
    44. //                }
    45. //            }
    46. //        }
    47. //    }
    48. //
    49. //class MyThread2 extends Thread{
    50. //    @Override
    51. //    public void run() {
    52. //        for (int i = 0; i < 100; i++) {
    53. //            if (i % 2 == 1){
    54. //                System.out.println(MyThread1.currentThread().getName() + ":" + i);
    55. //            }
    56. //        }
    57. //    }
    58. //}

    包含了匿名内部类和写两个子类的方法

    Thread类的常用方法：

    • 测试Thread中的常用方法：
    • 1、start()：启动当前线程，调用当前线程的run();
    • 2、run()：通常需要重写此方法，将要实现的代码写在这个方法中;
    • 3、currentThread()：静态方法，返回当前代码的线程;
    • 4、getName()：获取当前线程的名字;
    • 5、setName()：设置当前线程的名字;
    • 6、yeld()：释放CPU，然后所有线程去抢;
    • 7、join()：让线程a阻塞，线程b加入进来，线程b执行完毕线程a才结束阻塞状态;
    • 8、stop()：结束线程的运行，已过时;
    • 9、sleep()：让线程休眠，单位毫秒;
    • 10、isAlive()：判断当前线程是否存活。

    线程的调度：
    2、如何测试线程的优先级：

    • getPriority():获取当前线程的优先级；
    • setPriority():设置分线程的优先级，CPU只是参考优先级设置，不是把优先级高的跑完再跑优先级低的。

    卖票：

    1. package com.codeday23.demo01;
    3. /**
    4.  * 创建三个窗口买票，总票数100张
    5.  */
    6. public class Window extends Thread{
    8.     private static int ticket = 100;// 这里有线程的安全问题
    10.     @Override
    11.     public void run() {
    12.         while(true){
    13.             if(ticket > 0) {
    14.                 System.out.println(getName() + ":卖票，票号为：" + ticket);
    15.                 ticket--;
    16.             }else{
    17.                 break;
    18.             }
    19.         }
    20.     }
    21. }
    23. package com.codeday23.demo01;
    25. public class WindowTest {
    26.     public static void main(String[] args) {
    27.         Window t1 = new Window();
    28.         Window t2 = new Window();
    29.         Window t3 = new Window();
    31.         t1.setName("窗口1");
    32.         t2.setName("窗口2");
    33.         t3.setName("窗口3");
    35.         t1.start();
    36.         t2.start();
    37.         t3.start();
    38.     }
    39. }

    多线程的方式二：

    1. package com.codeday23.demo01;
    3. /**
    4.  * 创建多线程的方式二：实现Runnable接口
    5.  * 1、创建一个实现了Runnable接口的类
    6.  * 2、实现类去实现Runnable中的抽象方法：run()
    7.  * 3、创建实现类的对象
    8.  * 4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
    9.  * 5、通过Thread类的对象调用start()
    10.  *
    11.  */
    13. //创建一个实现了Runnable接口的类
    14. class MThread implements Runnable{
    16.     //实现类去实现Runbale中的抽象方法：run()
    17.     @Override
    18.     public void run() {
    19.         for (int i = 0; i < 100; i++) {
    20.             if(i % 2 == 0){
    21.                 System.out.println(i);
    22.             }
    23.         }
    24.     }
    25. }
    27. public class ThreadTest {
    29.     public static void main(String[] args) {
    30.         //创建实现类的对象
    31.         MThread mThread = new MThread();
    32.         // 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
    33.         Thread t1 = new Thread(mThread);
    34.         // 通过Thread类调用start():①启动线程；②调用当前线程的run()-->调用了
    35.         // Runnable类型的target
    36.         t1.start();
    38.         // 再启动一个线程，遍历100以内的偶数
    39.         Thread t2 = new Thread(mThread);
    40.         t2.start();
    41.     }
    42. }

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

    联系：
    1、两种方式都需要重写run()，将线程要执行的逻辑声明再run()中。

    线程的生命周期：

    java：多线程 - 图1

    多线程的同步：
    卖票过程中出现重票、错票，原因是一个线程没有执行完毕，其他线程就参与了进来。
    如何解决：用🔒
    方式一：同步代码块

    1. synchronized(同步监视器){
    2.     // 需要被同步的代码
    3. }

    说明：
    1、操作共享数据的代码，即为需要被同步的代码； 不能包含代码多了，也不能包含少了。
    2、共享数据：多个线程共同操作的变量。比如：ticket；
    3、同步监视器，就是🔒。任何一个类的对象，都可以充当锁，多个线程必须公用同一把🔒。

    补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
    在继承Thread类创建多线程的方式中，慎用this充当同步监视器。

    1. package com.codeday23.demo02;
    3. class Window1 implements Runnable{
    5.     private int ticket = 100;
    6.     Object obj = new Object();
    8.     @Override
    9.     public void run() {
    10.         while(true){ // 这里的while语句是为了让程序执行完一次后退出循环重新判断条件
    11.             // 不加while，程序会一直在里面执行
    12.             synchronized (obj) {
    13.                 if (ticket > 0) {
    15.                     try {
    16.                         Thread.sleep(200);
    17.                     } catch (InterruptedException e) {
    18.                         e.printStackTrace();
    19.                     }
    21.                     System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
    22.                     ticket--;
    23.                 } else {
    24.                     break;
    25.                 }
    26.             }
    27.         }
    28.     }
    29. }
    31. public class WindowTest1 {
    32.     public static void main(String[] args) {
    33.         Window1 w1 = new Window1();
    35.         Thread t1 = new Thread(w1);
    36.         Thread t2 = new Thread(w1);
    37.         Thread t3 = new Thread(w1);
    39.         t1.start();
    40.         t2.start();
    41.         t3.start();
    43.     }
    44. }

    方式二：同步方法
    如果操作共享数据的代码完整地生命在一个方法中，可以将此方法声明为同步。
    总结：
    1、同步方法依然涉及同步监视器，只是不需要我们显式的声明；
    2、非静态的同步方法，同步监视器是this，静态的同步方法是this.class。

    1. package com.codeday23.demo02;
    3. public class WindowTest3 {
    4.     public static void main(String[] args) {
    5.         Window1 w1 = new Window1();
    7.         Thread t1 = new Thread(w1);
    8.         Thread t2 = new Thread(w1);
    9.         Thread t3 = new Thread(w1);
    11.         t1.start();
    12.         t2.start();
    13.         t3.start();
    15.     }
    17. }
    20. class Window3 implements Runnable{
    22.     private int ticket = 100;
    24.     @Override
    25.     public void run() {
    26.         while(true){
    28.             show();
    30.         }
    31.     }
    33.     private synchronized void show(){// 同步监视器是：this
    35.         if (ticket > 0) {
    37.             try {
    38.                 Thread.sleep(100);
    39.             } catch (InterruptedException e) {
    40.                 e.printStackTrace();
    41.             }
    43.             System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
    44.             ticket--;
    45.         }
    46.     }
    47. }

    继承Thread类的多线程方法使用同步方法：

    1. package com.codeday23.demo02;
    3. import com.codeday23.demo01.Window;
    5. public class WindowTest4 {
    6.     public static void main(String[] args) {
    7.         Window4 t1 = new Window4();
    8.         Window4 t2 = new Window4();
    9.         Window4 t3 = new Window4();
    11.         t1.setName("窗口1");
    12.         t2.setName("窗口2");
    13.         t3.setName("窗口3");
    15.         t1.start();
    16.         t2.start();
    17.         t3.start();
    18.     }
    19. }
    21. class Window4 extends Thread{
    23.     private static int ticket = 100;// 这里有线程的安全问题
    25.     @Override
    26.     public void run() {
    27.         while(true){
    28.             show1();
    29.         }
    30.     }
    32.     private static synchronized void show1(){// 此时的同步监视器是this.class
    33.         if(ticket > 0) {
    35.             try {
    36.                 Thread.sleep(100);
    37.             } catch (InterruptedException e) {
    38.                 e.printStackTrace();
    39.             }
    41.             System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
    42.             ticket--;
    43.         }
    44.     }
    45. }

    单例设计模式：
    1、所谓类的单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例。
    ①饿汉式：私有化构造器，私有的静态属性是new一个对象，使用静态方法去调用这个属性，由于是静态的，所有怎么都只有一个对象；
    ②懒汉式：私有化构造器，私有的静态属性是一个空对象，判断instance是否为null，如果是null，new一个对象，否则直接返回instance。饿汉式是一个套娃结构，如果第一次调用get方法，会new一个该对象，第二次再调用，这个对象已经new了一个实例，就会跳过。

    懒汉式：

    1. class Bank1{
    3.     private Bank1(){
    5.     }
    7.     private static Bank1 b1 = null;// 这里需要注意，这只是调用构造器之后的初始化，
    8.     // 并不是说b1一直都是null
    10.     public static Bank1 getInstance(){
    11.         if(b1 == null){
    12.             Bank1 b1 = new Bank1();
    13.         }
    15.         return b1;
    16.     }
    17. }
    19. public class BankTest {
    20.     public static void main(String[] args) {
    22.         Bank b1 = Bank.getInstance();
    23.         Bank b2 = Bank.getInstance();
    25.         System.out.println(b1 == b2);
    27.     }
    28. }

    image.png

    使用同步机制将单例模式中的懒汉式改写为线程安全的：

    1. class Bank {
    3.     private Bank() {
    4.     }
    6.     private static Bank instance = null;
    8.     public static Bank getInstance() {
    9.         // 方法一：效率稍差，因为所有线程都要进入同步代码块
    10. //        synchronized (Bank.class) {
    11. //            if (instance == null) {
    12. //                instance = new Bank();
    13. //            }
    14. //            return instance;
    15. //        }
    17.         // 方法二：
    19.         if (instance == null) {
    21.             synchronized (Bank.class) {
    22.                 if (instance == null) {
    24.                     instance = new Bank();
    25.                 }
    27.             }
    28.         }
    29.         return instance;
    30.     }
    31. }

    线程的死锁问题：不同线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己的同步资源，就形成了线程的死锁。
    代码：

    1. package com.codeday23.demo03;
    3. public class ThreadTest {
    5.     public static void main(String[] args) {
    7.         StringBuffer s1 = new StringBuffer();
    8.         StringBuffer s2 = new StringBuffer();
    10.         new Thread(){
    11.             @Override
    12.             public void run() {
    14.                 synchronized (s1){
    16.                     s1.append("a");
    17.                     s2.append("1");
    19.                     try {
    20.                         Thread.sleep(100);
    21.                     } catch (InterruptedException e) {
    22.                         e.printStackTrace();
    23.                     }
    25.                     synchronized (s2){
    26.                         s1.append("b");
    27.                         s2.append("2");
    29.                         System.out.println(s1);
    30.                         System.out.println(s2);
    31.                     }
    32.                 }
    33.             }
    34.         }.start();
    36.         new Thread(new Runnable(){
    38.             @Override
    39.             public void run() {
    40.                 synchronized (s2){
    42.                     s1.append("c");
    43.                     s2.append("3");
    45.                     try {
    46.                         Thread.sleep(100);
    47.                     } catch (InterruptedException e) {
    48.                         e.printStackTrace();
    49.                     }
    51.                     synchronized (s1){
    52.                         s1.append("d");
    53.                         s2.append("4");
    55.                         System.out.println(s1);
    56.                         System.out.println(s2);
    57.                     }
    58.                 }
    59.             }
    60.         }).start();
    61.     }
    62. }

    我的理解：
    首先，统共两个线程，不分先后顺序。当线程1执行时，手中拿着S1的锁，代码块被执行，然后阻塞100ms。与此同时，在线程1阻塞的过程中，线程2极有可能开始执行，并且手中持有S2的锁。当线程1醒后，想去拿S2的锁执行下一个代码块的内容，发现线程2还在阻塞，无法拿到，就开始僵持，出现死锁。

    线程安全方法三，公平锁：

    1. package com.codeday23.demo03;
    3. import java.util.concurrent.locks.ReentrantLock;
    5. /**
    6.  * 解决线程安全问题的方式三：Lock锁 -----JDK 5.0新增
    7.  *
    8.  */
    10. class Window implements Runnable{
    12.     private int ticket = 100;
    14.     private ReentrantLock lock = new ReentrantLock();
    16.     @Override
    17.     public void run() {
    18.         while (true){
    20.             try {
    22.                 //2、调用锁定的方法lock
    23.                 lock.lock();
    25.                 if(ticket > 0) {
    27.                     try {
    28.                         Thread.sleep(100);
    29.                     } catch (InterruptedException e) {
    30.                         e.printStackTrace();
    31.                     }
    33.                     System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket);
    34.                     ticket--;
    35.                 }else{
    36.                     break;
    37.                 }
    39.             }finally {
    40.                 //3、调用解锁的方法
    41.                 lock.unlock();
    42.             }
    44.         }
    45.     }
    46. }
    48. public class LockTest {
    50.     public static void main(String[] args) {
    51.         Window w = new Window();
    53.         Thread t1 = new Thread(w);
    54.         Thread t2 = new Thread(w);
    55.         Thread t3 = new Thread(w);
    57.         t1.setName("窗口1");
    58.         t2.setName("窗口2");
    59.         t3.setName("窗口3");
    61.         t1.start();
    62.         t2.start();
    63.         t3.start();
    64.     }
    65. }

    同步和公平锁的区别：
    相同：二者都是用来解决线程安全问题的。
    不同：同步在执行完相应的代码后自动解锁，lock需要手动实现解锁

    注意：lock对象同样需要做到统一，不能有多个lock对象。

    一个三个用户存款的实现代码：

    1. package com.codeday24.demo01;
    3. import com.codeday13.A;
    5. import java.util.AbstractCollection;
    7. /**
    8.  * 银行有一个账户
    9.  *
    10.  * 有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
    11.  *
    12.  * 分析：
    13.  * 1、是否有多线程问题？ 有
    14.  * 2、是否有共享数据？ 是
    15.  * 3、是否有线程安全问题？ 是
    16.  * 4、需要考虑如何解决线程安全问题。同步机制，三种方式。
    17.  *
    18.  */
    20. class Account{
    22.     private static double balance;
    24.     public static void deposit(double amt){
    25.         balance += amt;
    27.         try {
    28.             Thread.sleep(100);
    29.         } catch (InterruptedException e) {
    30.             e.printStackTrace();
    31.         }
    33.         if(balance >= 0) {
    35.             System.out.println(Thread.currentThread().getName() + "存钱成功，余额为：" + balance);
    36.         }else{
    37.             System.out.println("余额不足！！");
    38.         }
    39.     }
    41.     public double getBalance(){
    42.         return balance;
    43.     }
    44. }
    46. class Customer extends Thread{
    48.     private Account acct;
    50.     public Customer(Account acct) {
    51.         this.acct = acct;
    52.     }
    54.     private static Object obj = new Object();
    56.     @Override
    57.     public void run() {
    59.         synchronized (obj){
    61.             for (int i = 0; i < 3; i++) {
    62.                 acct.deposit(1000);
    63.             }
    64.         }
    65.     }
    66. }
    68. public class AccountTest {
    70.     public static void main(String[] args) {
    71.         Account acct = new Account();
    72.         Customer c1 = new Customer(acct);
    73.         Customer c2 = new Customer(acct);
    75.         c1.setName("甲");
    76.         c2.setName("乙");
    78.         c1.start();
    79.         c2.start();
    81.     }
    82. }

    新增线程创建方式，实现Callable接口：

    1. package com.codeday25.demo01;
    3. import java.util.concurrent.Callable;
    4. import java.util.concurrent.ExecutionException;
    5. import java.util.concurrent.Future;
    6. import java.util.concurrent.FutureTask;
    8. /**
    9.  * 创建线程得方式三：实现Callable接口。
    10.  *
    11.  * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建都线程方式强大？
    12.  * 1、call()有返回值；
    13.  * 2、call()方法可以抛出异常，被外面的操作捕获；
    14.  * 3、Callable支持泛型
    15.  *
    16.  */
    18. // 1、创建一个实现Callable的实现类
    19. class NumThread implements Callable{
    21.     // 实现call方法，将此线程需要执行的操作写在这里面。
    22.     @Override
    23.     public Object call() throws Exception {
    25.         int sum = 0;
    26.         for (int i = 1; i <= 100; i++) {
    27.             if (i % 2 == 0){
    28.                 System.out.println(i);
    29.                 sum += i;
    30.             }
    31.         }
    32.         return sum;
    33.     }
    34. }
    36. public class ThreadNew {
    37.     public static void main(String[] args) {
    39.         // 3、创建Callable接口实现类的对象
    40.         NumThread numThread = new NumThread();
    41.         // 4、将次Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
    42.         FutureTask futureTask = new FutureTask(numThread);
    43.         // 5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
    44.         new Thread(futureTask).start();
    46.         try {
    47.             // 6、获取Callable中call方法中的返回值
    48.             // get()的返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
    49.             Object sum = futureTask.get();
    50.             System.out.println(sum);
    51.         } catch (InterruptedException e) {
    52.             e.printStackTrace();
    53.         } catch (ExecutionException e) {
    54.             e.printStackTrace();
    55.         }
    57.     }
    58. }

    线程池：

    1. package com.codeday25.demo02;
    3. import java.util.concurrent.ExecutorService;
    4. import java.util.concurrent.Executors;
    5. import java.util.concurrent.ThreadPoolExecutor;
    7. /**
    8.  * 创建线程的方式四：创建线程池
    9.  *
    10.  * 优点：
    11.  *  提高响应速度（减少了创建新线程的时间）
    12.  *  降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    13.  *  便于线程管理
    14.  *   
    15.  *  1）corePoolSize：核心池的大小
    16.  *  2）maximumPoolSize：最大线程数
    17.  *  3）keepAliveTime：线程没有任务时最多保持多长时间后会终止
    18.  *
    19.  * 创建多线程有四种方式
    20.  */
    22. class NumberThread implements Runnable {
    24.     @Override
    25.     public void run() {
    26.         for (int i = 0; i <= 100; i++) {
    27.             if (i % 2 == 0) {
    28.                 System.out.println(Thread.currentThread().getName() + " " + i);
    29.             }
    30.         }
    31.     }
    32. }
    34. class NumberThread1 implements Runnable{
    36.     @Override
    37.     public void run() {
    38.         for (int i = 0; i <= 100; i++) {
    39.             if (i % 2 != 0){
    40.                 System.out.println(Thread.currentThread().getName() + i);
    41.             }
    42.         }
    43.     }
    44. }
    47. public class ThreadPool {
    49.     public static void main(String[] args) {
    51.         // 1、提供指定线程数量的线程池
    52.         ExecutorService service = Executors.newFixedThreadPool(10);
    53.         ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
    55.         // 设置线程属性(这就是管理)
    56. //        System.out.println(service.getClass());// 获取该对象的类，结果是ThreadPoolExecutor
    57.         service1.setCorePoolSize(15);
    58. //        service1.setKeepAliveTime();
    60.         // 2、执行指定的线程操作，需要提供实现Runnable接口或Callable接口实现类的对象
    61.         service.execute(new NumberThread());// 适用于Runnable
    62.         service.execute(new NumberThread1());// 适用于Runnable
    63. //          service.submit();// 适用于Callable
    64.         // 3、关闭连接池
    65.         service.shutdown();// 关闭线程池
    66.     }
    67. }