Java多线程（案例+解析）基本概念:程序、进程、线程、使用多线程，Thread当中有关的方法，线程的调度，解决线程安全问题

Java多线程（案例+解析）基本概念
Java多线程（案例+解析）进阶部分：线程安全懒汉模式，线程锁死问题
Java多线程（案例+解析）中级部分：线程的通信
Java多线程（案例+解析）JDK5.0新增的线程的创建方式

一、基本概念:程序、进程。线程

●程序(program)是为完成特定任务、用某种语言编写的一-组指令的集合。

➢即指一段静态的代码，静态对象。

●进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。

生命周期
➢如:运行中的QQ，运行中的MP3播放器 ➢程序是静态的，进程是动态的
➢进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

●线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

➢若一个进程同一时间并行执行多个线程，就是支持多线程的
➢线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
➢一个进程中的多个线程共享相同的内存单元/内存地址空间>它们从同一堆中分配对象，可以访问相同的变量和对象。
这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

●单核CPU和多核CPU的理解

➢单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。

例如:虽然有多车道但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。
如果有某个人不想交钱，那么收费人员可以把他“挂起”(晾着他，等他想通了，准备好了钱，再去收费)。
但是因为CPU时间单元特别短，因此感觉不出来。

➢如果是多核的话，才能更好的发挥多线程的效率。(现在的服务器都是多核的)
➢一个Java应用程序java.exe，其实至少有三个线程: main()主线程，gc()
垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

在这里插入图片描述

●并行与并发

➢并行:多个CPU同时执行多个任务。比如:多个人同时做不同的事。
在这里插入图片描述
➢并发:一个CPU(采用时间片)同时执行多个任务。比如:秒杀、多个人做同一件事。
一个CUP执行多个任务通过时间分配，不同的任务

二、使用多线程

1、使用多线程的优点

背景:
以单核CPU为例，只使用单个线程先后完成多个任务(调用多个方法)，肯定比用多个线程来完成用的时间更短，为何仍需多线程呢?

多线程程序的优点:

（1）提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
（2）提高计算机系统CPU的利用率
（3）改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和
修改。

2、何时需要创建多线程

●程序需要同时执行两个或多个任务。

●程序需要实现- -些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

●需要一些后台运行的程序时。

3、线程的创建和使用

（1）下面这是一个单线程

在这里插入图片描述

（2）线程的创建和启动

●Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread
类来体现。

●Thread类的特性

➢每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体

➢通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

案例

package com.itzheng.test;
/*
创建多线程，方式一，继承与Thread类的方式
1、创建一个继承与Thread类的子类
2、重写Thread类当中的run方法--->將此線程要執行的操作聲明在run方法當中
3、创建Thread类的子类的对象
4、通过此对象调用start()方法
例子：遍历100以内的所有的偶数
 */
//1、创建一个继承与Thread类的子类
class MyThread extends Thread{
    
    
// 2、重写Thread类当中的run方法
    @Override
    public void run() {
    
    
        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 t1 = new MyThread();
        //4、通过此对象调用start()方法
        t1.start();
        System.out.println("hello");
    }
}

输出了0到100内的偶数

在这里插入图片描述
因为在main当中只有一条输出语句所以执行速度快先执行完

修改上面的main方法当中的内容

输出结果

（1）启动当前线程（2）调用当前线程的run方法(由于子类重写了父类的方法，所以直接调用子类当中重写父类的方法)
###### （3）
注意事项不可以直接调用run方法，这样就不是多线程只是单纯的在主线程当中调用run方法
修改ThreadTest和MyThread

package com.itzheng.test;
/*
创建多线程，方式一，继承与Thread类的方式
1、创建一个继承与Thread类的子类
2、重写Thread类当中的run方法--->將此線程要執行的操作聲明在run方法當中
3、创建Thread类的子类的对象
4、通过此对象调用start()方法
例子：遍历100以内的所有的偶数
 */
//1、创建一个继承与Thread类的子类
class MyThread extends Thread{
    
    
// 2、重写Thread类当中的run方法
    @Override
    public void run() {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            if(i % 2 == 0){
    
    
                System.out.println(Thread.currentThread().getName() + ":"+ i);
            }
        }
    }
}
public class ThreadTest {
    
    
    public static void main(String[] args) {
    
    
        //3、创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //4、通过此对象调用start()方法
        // （1）启动当前线程 （2）调用当前线程 的run方法(由于子类重写了父类的方法，所以直接调用子类当中重写父类的方法)
        //t1.start();
        t1.run();
        //如下的操作任然是在main（主线程当中执行的）。
        System.out.println("hello");
        for (int i = 0; i < 100; i++) {
    
    
            if(i % 2 == 0){
    
    
                System.out.println(Thread.currentThread().getName() + ":"+i+"-main-");
            }
        }
    }
}

输出结果
在这里插入图片描述
从结果可以分析得出，当通过t1只调用run方法的时候，只有一条主线程

（4）当t1通过start方法调用的时候

在这里插入图片描述

从Thread的名称可以看出调用的不是同一个线程
在这里插入图片描述

4、再启动一个线程，遍历100以内的偶数

注意一个线程只能start一次，不可以还让已经statrt()的线程去执行。会报IllegalThreadStateException异常

（1）再创建一个线程需要再创建MyThread对象为t2（我们需要从新创建一个线程的对象）

在这里插入图片描述
从运行结果可以看出同时三个线程在运行（我们需要从新创建一个线程的对象）

在这里插入图片描述

5、练习

（1）一个线程遍历奇数一个线程遍历偶数

package com.itzheng.test2;
/*
练习：创建两个分线程，其中的一个线程遍历100以内的偶数，另外一个线程遍历100以内的奇数
 */
public class ThreadDemo {
    
    
    public static void main(String[] args) {
    
    
        MyThread1 t1 = new MyThread1();
        t1.setA(6);
        t1.start();
        MyThread1 t2 = new MyThread1();
         t2.setA(1);
        t2.start();
    }
}
class MyThread1 extends Thread{
    
    
    private int a;
    @Override
    public void run() {
    
    
        bianli(a);
    }
    public void setA(int a){
    
    
        this.a=a;
    }
    public void bianli(int a){
    
    
        //如果a 等于1编辑奇数如果a等于2遍历偶数
        for (int i = 0; i < 100; i++) {
    
    
            if(a == 1){
    
    
                if( i % 2 == 1){
    
    
                    System.out.println(i+"奇数");
                }
            }else{
    
    
                if( i % 2 == 0){
    
    
                    System.out.println(i+"偶数");
                }
            }
        }
    }
}

在这里插入图片描述

（2）简化上述代码（创建Thread类的匿名子类的方式）

public class ThreadDemo {
    
    
    public static void main(String[] args) {
    
    
        new Thread(){
    
    
            @Override
            public void run() {
    
    
                for (int i = 0; i < 100; i++) {
    
    
                    if( i % 2 == 1)
                    {
    
    
                        System.out.println(i+"奇数");
                    }
                }
            }
        }.start();
        new Thread(){
    
    
            @Override
            public void run() {
    
    
                for (int i = 0; i < 100; i++) {
    
    
                    if( i % 2 == ）)
                    {
    
    
                        System.out.println(i+"偶数");
                    }
                }
            }
        }.start();
    }
}

三、Thread当中有关的方法

创建测试类

package com.itzheng.test2;
/*
测试Thread类当中常用方法：
 */
class MyThread extends Thread{
    
    
    @Override
    public void run() {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            if(i % 2 == 0){
    
    
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
public class ThreadMethodTest {
    
    
    public static void main(String[] args) {
    
    
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

● 1、void start():启动当前线程，并执行对象的run()方法
● 2、run():线程在被调度时执行的操作

通常需要重写Thread类当中的run方法，将创建的线程执行操作声明再run方法当中

● 3、String getName():返回线程的名称

获取当前线程的名字

● 4、void setName(String name):设置该线程名称
● 5、static Thread currentThread():返回当前线程。在Thread 子类中就是this，通常用于主线程和Runnable实现类

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

● 6、static void yield():线程让步

➢暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
➢若队列中没有同优先级的线程，忽略此方法

● 7、join() :当某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到join()方法加入的join线程执行完为止

➢低优先级的线程也可以获得执行

● 8、static void sleep(long millis): (指定时间:毫秒)

➢令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
➢抛出InterruptedException异常

● 9、stop():强制线程生命期结束，不推荐使用
● 10、boolean isAlive(): 返回boolean, 判断线程是否还活着

四、线程的调度

1、调度策略

➢时间片

在这里插入图片描述

➢抢占式:高优先级的线程抢占CPU

●Java的调度方法

➢同优先级线程组成先进先出队列( 先到先服务)，使用时间片策略
➢对高优先级，使用优先调度的抢占式策略

2、线程的优先级别

（1）线程的优先级等级

➢MAX_ PRIORITY: 10：最大优先级
➢MIN_ PRIORITY: 1：最小优先级
➢NORM_ PRIORITY: 5：默认优先级

（2）如何获取和设置当前线程的优先级

➢getPriority() :返回线程优先级的值（获取线程的优先级）
➢setPriority(int newPriority):设置改变线程的优先级（设置线程优先级）

（3）说明

➢线程创建时继承父线程的优先级
➢低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

3、获取当先线程优先级（代码）

在这里插入图片描述

运行返回结果：默认线程的优先级别为NORM_ PRIORITY: 5

全部代码

package com.itzheng.test2;
import static java.lang.Thread.sleep;
/*
测试Thread类当中常用方法：
 */
class MyThread extends Thread{
    
    
    @Override
    public void run() {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            if(i % 2 == 0){
    
    
                System.out.println(getName() + ":当前线程优先级别为：" + getPriority() + ":" + i);
            }
        }
    }
    public MyThread(String name){
    
    
        super(name);
    }
}
public class ThreadMethodTest {
    
    
    public static void main(String[] args) {
    
    
        MyThread myThread = new MyThread("线程一：通过构造方法创建的");
       // myThread.setName("线程一");
        myThread.start();
        //给主线程命名
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 100; i++) {
    
    
            if(i % 2 == 0){
    
    
                try {
    
    
                    sleep(10);//当主线程执行到这里时候阻塞主线程，主线程等待1秒以后开始执行
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":当前线程优先级别为：" + Thread.currentThread().getPriority() + ":" + i);
            }
            if(i == 20){
    
    
                try {
    
    
                    myThread.join();
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
        System.out.println(myThread.isAlive());
    }
}

4、修改线程优先级别

在分线程start之前，设置分线程的优先级别（设置分线程的优先级别为最大10，设置主线程优先级别为1最小）
将主线程的join方法去掉，因为join方法会影响线程优先级，将sleep也去掉
在这里插入图片描述
优先执行线程级别较高线程（但是也有交互调用的现象），并不一定是优先级高的一定先执行，是优先级高的概率较高的执行，高优先级的线程要抢占低优先级CPU 的执行权，但是只是从概率上讲高优先级的线程高概率的情况下被执行，并不意味着，只有当高优先级别的线程完以后低优先级的线程才执行。
在这里插入图片描述
全部代码

package com.itzheng.test2;
import static java.lang.Thread.MIN_PRIORITY;
import static java.lang.Thread.sleep;
/*
测试Thread类当中常用方法：
 */
class MyThread extends Thread{
    
    
    @Override
    public void run() {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            if(i % 2 == 0){
    
    
                System.out.println(getName() + ":当前线程优先级别为：" + getPriority() + ":" + i);
            }
        }
    }
    public MyThread(String name){
    
    
        super(name);
    }
}
public class ThreadMethodTest {
    
    
    public static void main(String[] args) {
    
    
        MyThread myThread = new MyThread("线程一：通过构造方法创建的");
       // myThread.setName("线程一");

        //设置分线程的优先级别
        myThread.setPriority(Thread.MAX_PRIORITY);
        myThread.start();
        //给主线程命名
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(MIN_PRIORITY);
        for (int i = 0; i < 100; i++) {
    
    
            if(i % 2 == 0){
    
    
                System.out.println(Thread.currentThread().getName() + ":当前线程优先级别为：" + Thread.currentThread().getPriority() + ":" + i);
            }

        }
        System.out.println(myThread.isAlive());
    }
}

五、创建多线程的第一种方式（继承Thread，实现多窗口买票）

案例一

package com.itzheng.test2;
/*
例子：创建三个C窗口买票，总票数为100张
 */
class Window extends Thread{
    
    
    private int ticket = 100;
    @Override
    public void run() {
    
    
        while(true){
    
    
            if(ticket > 0){
    
    
                System.out.println(Thread.currentThread().getName()+":买票，票号为："+ticket);//获取当前线程的名称
                ticket --;
            }else{
    
    
                break;
            }
        }
    }
}
public class WindowTest {
    
    
    public static void main(String[] args) {
    
    
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

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

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

运行上述代码发现一些问题
票号为100的票被三个窗口买了3次不合理
因为创建了三个对象，没一个人都有100张票分别买每个人自己的那张票
在这里插入图片描述

案例二，对上述代码进行修改

1、将票的数量的定义为静态的变量，三个线程共用一个变量

在这里插入图片描述

package com.itzheng.test2;

/*
例子：创建三个C窗口买票，总票数为100张
 */

class Window extends Thread{
    
    
    private static int ticket = 100;
    @Override
    public void run() {
    
    
        while(true){
    
    
            if(ticket > 0){
    
    
                System.out.println(Thread.currentThread().getName()+":买票，票号为："+ticket);//获取当前线程的名称
                ticket --;
            }else{
    
    
                break;
            }
        }
    }
}
public class WindowTest {
    
    
    public static void main(String[] args) {
    
    
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

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

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

2、虽然这样大部分的重复内容都没有了但是依旧一重复的数据（线程不安全的问题）后面会介绍

在这里插入图片描述

六、创建多线程的第二种方式（实现Runnable接口，实现多窗口买票）

1、创建MThread 类实现Runnable接口

当前线程t1 的run方法调用了Runnable类型的target的run方法，而当通过new Thread(mThread);有构造参数的方式创建对象的时候，target的值不为空，就调用了target的run方法（从外面看是调用了当前线程的run方法）

1、创建实现了Runnable接口的类
2、实现类去实现Runnable接口当中的抽象方法：run()
3、创建实现类的对象
4、将次对象作为参赛传递到Thread这个类的构造器当中，然后去创建Thread类的对象
5、通过Thread类的对象去调用start()方法

package com.itzheng.test2;
/*
创建多线程的方式二：实现Runnable接口
1、创建实现了Runnable接口的类
2、实现类去实现Runnable接口当中的抽象方法：run()
3、创建实现类的对象
4、将次对象作为参赛传递到Thread这个类的构造器当中，然后去创建Thread类的对象
5、通过Thread类的对象去调用start()方法
 */
//1、创建实现了Runnable接口的类
class MThread 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、创建实现类的对象
        MThread mThread = new MThread();
        //4、将次对象作为参赛传递到Thread这个类的构造器当中，然后去创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.start();//start方法有两个作用1、启动线程 2、调用当前线程的run()方法
    }
}

2、再启动一个线程、遍历100以内的偶数

在这里插入图片描述

package com.itzheng.test2;
/*
创建多线程的方式二：实现Runnable接口
1、创建实现了Runnable接口的类
2、实现类去实现Runnable接口当中的抽象方法：run()
3、创建实现类的对象
4、将次对象作为参赛传递到Thread这个类的构造器当中，然后去创建Thread类的对象
5、通过Thread类的对象去调用start()方法
 */
//1、创建实现了Runnable接口的类
class MThread implements  Runnable{
    
    
    //2、实现类去实现Runnable接口当中的抽象方法：run()
    @Override
    public void run() {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            if(i % 2 == 0){
    
    
                System.out.println(Thread.currentThread().getName()+":"+ i);
            }
        }
    }
}
public class ThreadTest1 {
    
    
    public static void main(String[] args) {
    
    
        //3、创建实现类的对象
        MThread mThread = new MThread();
        //4、将次对象作为参赛传递到Thread这个类的构造器当中，然后去创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程一");
        t1.start();

        //再创建一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程二");
        t2.start();
    }
}

执行结果
在这里插入图片描述

3、实现多窗口买票

（1）使用Runnable接口的方式代码

package com.itzheng.test;
/*
例子：创建三个C窗口买票，总票数为100张，使用Runnable接口的方式
 */
class Window1 implements Runnable{
    
    
    private int ticket = 100;
    @Override
    public void run() {
    
    
        while (true){
    
    
            if(ticket > 0){
    
    
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为："+ticket);
                ticket--;
            }else{
    
    
                break;
            }
        }
    }
}
public class WindowTest1 {
    
    
    public static void main(String[] args) {
    
    
        Window1 w = new Window1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口一");
        t2.setName("窗口三");
        t3.setName("窗口二");

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

运行结果依旧有重复的数据（虽然ticket 没有加static但是三个线程共用的同一个ticket ）这里重票的问题应为线程不安全的原因

上面这种方式只创建了一个买票的对象，放到了三个构造器当中，所以使用的是同一个ticket 变量
在这里插入图片描述

七、比较创建线程的两种方式：上诉两种方式创建线程使用实现接口的方式比较好

1、开发当中。优先使用实现Runnanle接口的方式

原因：
（1）实现的方式没有类的单继承性的局限性
（2）实现的方式更加适合来处理多个线程共享数据的情况。

在这里插入图片描述

2、两种方式之间的联系：

（1）Thread也实现了Runnable接口，当我们实现Runnable接口的时候，并重写run方法，两种方式都需要重写run方法，将线程要执行的逻辑声明在run方法当中。

八、线程的生命周期

1、在 Thread类当中的要 State枚举类，Thread.State类定义了线程的几种状态

    public enum State {
    
    
        NEW,//创建线程
        RUNNABLE,//执行线程就是让线程跑起来
        BLOCKED,//阻塞
        WAITING,//等待
        TIMED_WAITING,//等待可超时的
        TERMINATED;//生命周期结束
    }

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类
及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态:

➢新建:当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

➢就绪:处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源

➢运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态，run()方法定义了线程的操作和功能

➢阻塞:在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态

➢死亡:线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

2、线程的生命周期

在这里插入图片描述

九、线程安全问题

1、线程的同步：同步问题的提出（线程的安全模式）操作共享数据的时候可能出现问题

（1）执行上面创建好的WindowTest类会发现一些线程同步的问题

会发现票重复的问题也有可能发生错票的问题
在这里插入图片描述
➢多个线程执行的不确定性引起执行结果的不稳定
➢多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

（2）线程同步的理想状态

在这里插入图片描述

（3）线程同步的极端状态

在这里插入图片描述

2、线程的安全问题的举例和解决措施

（1）修改Window1当中run方法：添加sleep方法，提高出现错误的概率（原本就错误）错票，这下面这里添加方法错票的概率会增大

在这里插入图片描述
执行结果

会发现出现了负票的结果

（2）修改Window1当中run方法：添加sleep方法，提高出现错误的概率（原本就错误）重票，这下面这里添加方法重票的概率会增大

在这里插入图片描述
运行结果

3、总结问题原因以及解决问题

a、买票过程当中出现了重票和错票—>出现了线程的安全问题
b、问题出现的原因：当某个线程操作车票的过程当中，尚未操作完成时，其他线程参与进来，也操作这个车票（共享的数据，在继承创建线程的静态变量和实现接口创建线程的私有变量为共享数据）
c、如何解决：当线程a再操作共享数据（车票）的时候，b线程不能参与进来，直到线程a操作完毕共享数据（车票）时，其他线程才可以开始操作共享数据（车票），这种情况即使线程a出现了阻塞，也不能被改变。
d、在Java，我们通过同步机制，来解决线程的安全问题

十、我们通过同步机制，来解决线程的安全问题

方式一：同步代码块

1、处理Window1实现Runnable接口的方式，创建多线程的线程安全问题

（1）语法

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

（2）说明：操作共享数据的代码，即为需要被同步的代码

被synchronized包含的线程执行完毕后其他线程才可以执行，被synchronizd包括的为需要被同步的代码
在这里插入图片描述

（3）共享数据：多个线程共同操作的变量或者数据为共享数据，比如本问题当做的ticket就是共享数据。

（4）同步监视器，俗称：锁。任何一个类的对象都可以来充当锁，要求：`多个线程必须使用同一把锁。`

（5）修改上述案例

在这里插入图片描述

package com.itzheng.java;
/*
例子：创建三个C窗口买票，总票数为100张，使用Runnable接口的方式
 */
class Window1 implements Runnable{
    
    

    private int ticket = 100;

    Object obj = new Object();
    @Override
    public void run() {
    
    
        while (true){
    
    
            //当循环完一次后线程解锁，后其他线程可以抢ticket共享资源，当另外一个循环解锁后又有可能会回到当前线程当中
            // 在执行一个线程的时候资源又被加锁，
            // 其他线程如果想调用当前资源就必须等待当前线程执行完，解锁后其他线程才可以使用该共享资源
            synchronized(obj){
    
    
                if(ticket > 0){
    
    
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为："+ticket);
                    try {
    
    
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
    
    
                        e.printStackTrace();
                    }
                    ticket--;
                }else{
    
    
                    break;
                }
            }
        }
    }
}
public class WindowTest1 {
    
    
    public static void main(String[] args) {
    
    
        Window1 w = new Window1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口一");
        t2.setName("窗口三");
        t3.setName("窗口二");

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

运行结果。解决线程不安的问题
在这里插入图片描述

（6）也可用this表示当前唯一对象，此时的this代表唯一window1的对象

在这里插入图片描述

（7）同步的方式的优点和缺点

优点：解决了线程的安全问题。

局限性：操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

2、处理Window2继承Thread类，创建多线程的线程安全问题

（1）声明静态的int类型的ticket变量，以及static静态的Object对象

package com.itzheng.java;
/*
例子：创建三个C窗口买票，总票数为100张
 */
class Window2 extends Thread{
    
    
    private static int ticket = 100;
    private static Object obj = new Object();
    @Override
    public void run() {
    
    
        while(true){
    
    
            synchronized (obj) {
    
    
                if (ticket > 0) {
    
    
                    try {
    
    
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
    
    
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);//获取当前线程的名称
                    ticket--;
                } else {
    
    
                    break;
                }
            }
        }
    }
}
public class WindowTest2 {
    
    
    public static void main(String[] args) {
    
    
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

在这里插入图片描述

（2）不可以用this来代表（下面是错误的方式）

在这里插入图片描述
此时的this代表了三个对象，t1，t2，t3三个对象
对象不唯一锁就不唯一，造成线程不安全的的问题

（3）使用Window2.class对象，作为唯一的锁，类也是对象

在这里插入图片描述
也可以实现线程安全

说明：继承Thread类创建多线程的方式当中，慎用this充当同步监视器。考虑使用当前类充当同步监视器。

操作共享数据的代码，既为需要被同步的代码，不能包含多了，也不能包含代码少了（多包含了可以造成效率低下的问题-也可能造成逻辑的错误，少包了可以造成线程不安全的问题）

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法当中，不妨将此方法声明为同步的方法。

1、使用同步方法解决，实现Runnable接口的线程安全问题

创建Window3类，抽取同方法，同步分内为要共享的数据，在同步方法当中始终只能执行一个线程，同步方法当中自动会创建：在这里的同步监视器就是this
在这里插入图片描述

package com.itzheng.test;
/*
使用同步方法解决，实现Runnable接口的线程安全问题
 */
class Window3 implements Runnable {
    
    
    private int ticket = 100;

    @Override
    public void run() {
    
    
        while (true) {
    
    
            show();
        }
    }

    private synchronized void show() {
    
    
        if (ticket > 0) {
    
    
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            try {
    
    
                Thread.sleep(100);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            ticket--;
        }else{
    
    
            return;
        }
    }
}

public class WindowTest3 {
    
    
    public static void main(String[] args) {
    
    
        Window3 w = new Window3();//创建一个传递三个所以当前对象是唯一的
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口一");
        t2.setName("窗口三");
        t3.setName("窗口二");

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

2、使用同步方法解决，继承Thread类的线程安全问题

（1）在Window4当中Window4继承Thread类，使用同步方法show来处理线程安全问题

同步监视器：t1,t2,t3
在这里插入图片描述

依旧线程不安全
在这里插入图片描述

（2）使用静态来修饰同步方法，解决上述问题

同步监视器为当前Window4.class
在这里插入图片描述

package com.itzheng.test;
/*
例子：创建三个C窗口买票，总票数为100张
使用同步方法处理继承Thread类的方式当中的线程安全问题
 */
class Window4 extends Thread {
    
    
    private static int ticket = 100;
    @Override
    public void run() {
    
    
        while (true) {
    
    
            show();
        }
    }
    private static  synchronized void show(){
    
    //同步监视器为当前Window4.class
        if (ticket > 0) {
    
    
            try {
    
    
                Thread.sleep(100);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);//获取当前线程的名称
            ticket--;
        }
    }
}
public class WindowTest4 {
    
    
    public static void main(String[] args) {
    
    
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();

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

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

运行结果
在这里插入图片描述

（3）关于同步方法的总结

a、同步方法依然设计到同步监视器，只是不需要我们显示的声明。
b、非静态的同步方法，同步监视器是：this
静态的同步方法，同步监视器：当前类本身，

Java多线程（案例+解析）基本概念
Java多线程（案例+解析）进阶部分：线程安全懒汉模式，线程锁死问题
Java多线程（案例+解析）中级部分：线程的通信
Java多线程（案例+解析）JDK5.0新增的线程的创建方式