十一、Properties、多线程

满山猴子我腚最红#

于 2023-01-01 19:41:40 发布

阅读量401

点赞数

分类专栏： JavaSE教程文章标签： java 后端

本文链接：https://blog.csdn.net/qq_61935150/article/details/128514866

版权

JavaSE教程专栏收录该内容

17 篇文章 1 订阅

订阅专栏

Properties集合

Properties作为Map集合的使用

介绍

是一个Map体系的集合类
Properties可以保存到流中或从流中加载
属性列表中的每个键及其对应的值都是一个字符串

基本使用

public static void main(String[] args) {
    Properties prop = new Properties();
    //增
    prop.put("小龙女", "尹志平");
    prop.put("郭襄", "杨过");
    prop.put("黄蓉", "欧阳克");
    System.out.println(prop);


    //删
    //prop.remove("郭襄");
    //System.out.println(prop);

    //改
    //put --- 如果键不存在,那么就添加,如果键存在,那么就覆盖.
    prop.put("小龙女", "杨过");
    System.out.println(prop);
    //查

    //Object value = prop.get("黄蓉");
    //System.out.println(value);

    //遍历
    Set<Object> keys = prop.keySet();
    for (Object key : keys) {
        Object value = prop.get(key);
        System.out.println(key + "=" + value);
    }

    System.out.println("========================");

    //装的是所有的键值对对象.
    Set<Map.Entry<Object, Object>> entries = prop.entrySet();
    for (Map.Entry<Object, Object> entry : entries) {
        Object key = entry.getKey();
        Object value = entry.getValue();
        System.out.println(key + "=" + value);
    }

}

Properties作为Map集合的特有方法

方法名	说明
Object setProperty(String key, String value)	设置集合的键和值，都是String类型，底层调用 Hashtable方法 put
String getProperty(String key)	使用此属性列表中指定的键搜索属性
Set stringPropertyNames()	从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串

代码

        Properties prop = new Properties();
        //1增
        prop.setProperty("小龙女", "尹志平");
        prop.setProperty("郭襄", "杨过");
        prop.setProperty("黄蓉", "欧阳克");

        //2获取
        System.out.println(prop.getProperty("小龙女"));
        System.out.println(prop.getProperty("郭襄"));
        System.out.println(prop.getProperty("黄蓉"));
        System.out.println(prop.getProperty("周芷若"));
        //参数2 是当key找不到时，返回指定的默认值
        System.out.println(prop.getProperty("神雕", "我叫默认值"));


        //3获取所有的key的set集合
        Set<String> keys = prop.stringPropertyNames();
        //遍历所有的key 获取对应的值
        for (String key : keys) {
            System.out.println(key + "----" + prop.getProperty(key));
        }

Properties和IO流相结合的方法

方法名	说明
void load(Reader reader)	从输入字符流读取属性列表（键和元素对）
void store(Writer writer, String comments)	将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流

代码1 Properties结合BufferedWriter存数据

保存的文件名字一般以.properties为后缀

public class Demo03 {
    public static void main(String[] args) throws IOException {


        Properties prop = new Properties();

        prop.setProperty("001", "xiaoming");
        prop.setProperty("002", "xiaohong");
        prop.setProperty("003", "xiaolan");

        prop.setProperty("小龙女", "尹志平");
        prop.setProperty("郭襄", "杨过");
        prop.setProperty("黄蓉", "欧阳克");


        BufferedWriter writer = new BufferedWriter(new FileWriter("a.properties"));

        //prop.store(writer, null);
        //保存数据到文件  参1是帮助写数据的流对象  参数2是保存的数据的说明 会写到文件里,可以不写 传null
        prop.store(writer, "保存的数据hello");


    }
}

代码1 Properties结合BufferedReader加载数据

Properties prop = new Properties();
BufferedReader br = new BufferedReader(new FileReader("a.txt"));

//从流中读取数据到集合
prop.load(br);

System.out.println(prop);

System.out.println(prop.getProperty("小龙女"));
System.out.println(prop.getProperty("郭襄"));
System.out.println(prop.getProperty("黄蓉"));

Properties集合练习（课下完成）

需求

在Properties文件中手动写上姓名和年龄,读取到Properties集合中,将该数据封装成学生对象,写到本地文件中

在这里插入图片描述

步骤

创建Properties集合,将本地文件中的数据加载到集合中
获取集合中的键值对数据,封装到学生对象中
创建序列化流对象,将学生对象序列化到本地文件中

代码实现

学生类

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类

public class Test {

    public static void main(String[] args) throws IOException {
      	//1.创建Properties集合对象,使用字符读取缓冲流将本地文件中的数据加载到集合对象中
        
		//2.获取集合中的键值对数据,封装到学生对象中
     
		//3.创建序列化流对象,将学生对象序列化到本地文件中
    }
}

多线程（重点重点重点重点重点重点重点重点）

目标：

1 线程的相关概念
2 线程创建和启动方法1和2（掌握）
3 线程创建和启动方法3 （掌握）
4 理解三种创建的区别

实现多线程方式一：继承Thread类

方法介绍

方法名说明
void run() 在线程开启后，此方法将被调用执行
void start() 使此线程开始执行，Java虚拟机会调用run方法
实现步骤
- 1定义一个类继承Thread类
- 2在类中重写run()方法
- 3用这个类创建对象
- 4用对象调用start 开启线程

方法名	说明
void run()	在线程开启后，此方法将被调用执行
void start()	使此线程开始执行，Java虚拟机会调用run方法

代码演示

注意：直接调用run方法不会开启线程

创建线程的类

public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 100; i++) {
            System.out.println("我唱歌" + i);
        }
    }
}

测试类中使用线程

public class Demo02 {
    public static void main(String[] args) {
        // 1 写一个类继承Thread
        //2 重写run方法
        //3 用这个类创建对象
        MyThread t1 = new MyThread();
        //4 用对象调用start 开启线程
        t1.start();

	 //再次创建一个线程
        MyThread t2 = new MyThread();
        //开启线程
        t2.start();
    }
}

Thread中的方法

构造方法：

Thread()：空参数的构造方法。
Thread(String name)：一个参数是字符串的构造方法，参数表示线程名字。

其它方法

String getName()：获取线程名字。
void setName(String name)：设置线程名字。
static Thread currentThread()：获取当前正在执行的线程对象。
static void sleep(long millis)：线程休眠，参数是休眠的毫秒值。

代码

实现两个子线程一个唱歌一个跳舞，主线程打篮球如下：

Thread子类的代码

两个子类，一个唱歌，一个跳舞，都写了空参和有参构造，有参构造里可以传入一个字符串给线程命名
在run中，调用了getName方法获取了线程的名字

public class MyThread extends Thread {

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 100; i++) {
            System.out.println("我唱歌" + i+"---"+getName());

        }
    }
}

class MyThread2 extends Thread {
    public MyThread2() {
    }

    public MyThread2(String name) {
        super(name);
    }

    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 100; i++) {
            System.out.println("我跳舞" + i+"---"+getName());
        }
    }
}

测试代码

创建Thread对象的时候，传入了线程的名字 sing和dance
主线程for循环中打篮球，通过Thread.currentThread() 获取当前线程对象然后getName()获取线程的名字

public class Demo05 {
    public static void main(String[] args) {
        // 1 写一个类继承Thread
        //2 重写run方法
        //3 用这个类创建对象
        MyThread t1 = new MyThread("sing");
        //4 用对象调用start 开启线程
        t1.start();


        MyThread2 t2 = new MyThread2("dance");
        t2.start();


        for (int i = 0; i < 100; i++) {
            System.out.println("我打篮球" + i);
            //Thread.currentThread() 获取当前线程对象 然后getName()获取线程的名字
            //这里是主线程 名字是main
            System.out.println(Thread.currentThread().getName());
        }
    }
}

线程流程图

在这里插入图片描述

实现多线程方式二：实现Runnable接口

Thread构造方法

方法名	说明
Thread(Runnable target)	分配一个新的Thread对象
Thread(Runnable target, String name)	分配一个新的Thread对象

实现步骤

定义一个类MyRunnable实现Runnable接口
在MyRunnable类中重写run()方法
创建MyRunnable类的对象
创建Thread类的对象，把MyRunnable对象作为构造方法的参数传入
调用Thread类的对象的start方法启动线程

Runnable代码

类MyRunnable实现Runnable接口,重写run()方法,
方法中Thread.currentThread().getName()获取了线程的名字

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("吃肉夹馍" + i);
            System.out.println(Thread.currentThread().getName());
        }
    }
}

线程测试代码

创建了三个线程
- 1 Thread t 在创建的时候，构造方法中传入了Runnable对象
- 2Thread t2，创建的时候使用lambda表达式传入了Runnable的实现类对象
- 3 直接在new Thread的时候使用lambda表达式传入了Runnable的实现类对象，然后直接start开启线程

        //1创建了MyRunnable对象 里面存放了要执行的任务
        MyRunnable r = new MyRunnable();

        //2创建线程对象 把Runnable对象r传入线程里
        //相当于把任务交给了线程
        Thread t = new Thread(r);

        //3 开启线程 会执行Runnable对象里的run方法
        t.start();


        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("吃西瓜" + i);
                System.out.println(Thread.currentThread().getName());
            }
        });

        t2.start();

        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("喝豆浆" + i);
                System.out.println(Thread.currentThread().getName());
            }
        }).start();

两种实现方式的区别

第一种方式：需要自定义类，继承Thread类——子类不能再继承其它类了，比较受限制！
第二种方式：需要自定义类，实现Runnable接口——对于子类更灵活,更方便代码的面向对象设计。

线程小结

在这里插入图片描述

多线程方式三: 实现Callable接口【应用】

方法介绍

方法名	说明
V call()	计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable callable)	创建一个 FutureTask，一旦运行就执行给定的 Callable
V get()	如有必要，等待计算完成，然后获取其结果

实现步骤
- 1定义一个类MyCallable实现Callable接口
- 2在MyCallable类中重写call()方法
- 3创建MyCallable类的对象
- 4创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
- 5创建Thread类的对象，把FutureTask对象作为构造方法的参数
- 6启动线程
- 7FutureTask对象来调用get方法，就可以获取线程结束之后的结果。

代码 Callable部分

定义一个类MyCallable实现Callable接口
重写call()方法方法的内容就是要执行的子线程的任务
方法的返回值可以在子线程结束后获取

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
            Thread.sleep(50);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}

代码测试部分

创建MyCallable类的对象 mc
创建FutureTask类的对象，把mc作为构造方法的参数传入
创建线程对象

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();

        //创建FutureTask对象ft 把mc传入，ft可以获取线程执行完毕之后的结果.
        //FutureTask本身实现了Runnable接口
        FutureTask<String> ft = new FutureTask<>(mc);

        //创建线程对象  ft作为参数传递给Thread对象
        Thread t1 = new Thread(ft);
        //System.out.println("1111");
        //String s = ft.get();//代码 阻塞
        //System.out.println("222");
        //开启线程
        t1.start();

        System.out.println("等待表白结果");
        String s = ft.get();
        System.out.println(s);
    }

第三种实现方式可以自己跟一下源码

线程方法回顾

获取线程对象
获取线程名字
sleep线程休息

在这里插入图片描述

线程优先级 Priority praɪˈɔːrəti

线程调度（了解）

两种调度方式
- 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
- 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
Java使用的是抢占式调度模型
随机性

假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

方法名	说明
final int getPriority()	返回此线程的优先级
final void setPriority(int newPriority)	更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

代码

注意优先级大，不一定先执行完，只是增加了抢占cpu的几率

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}

public class Demo02 {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();

        FutureTask<String> ft = new FutureTask<>(mc);

        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());//获取优先级 默认值是5
        t1.start();

        MyCallable mc2 = new MyCallable();

        FutureTask<String> ft2 = new FutureTask<>(mc2);

        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());//获取优先级 默认值是5
        t2.start();
    }
}

守护线程 Daemon diːmən 滴们

用户线程，jvm会等待用户线程全部结束，最后再结束程序.
守护线程, 当所有用户线程都结束后，由于jvm直接结束程序，守护线程会被直接结束掉
垃圾回收器就是一个守护线程
应用：一般写有一些监控功能的需求。比如定时器

设置的方法

方法名	说明
void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

代码

1代码有两个子线程t1和t2,唱歌和打球，主线程跳舞
2 设置t1和t2为守护线程，那么当用户线程执行完后，如果守护线程任务没有执行完，守护线程也会结束

public class Demo04 {
    public static void main(String[] args) {
        MThread1 t1 = new MThread1();
        //设置为守护线程
        t1.setDaemon(true);

        t1.start();

        MThread2 t2 = new MThread2();
        t2.setDaemon(true);
        t2.start();


        for (int i = 0; i < 100; i++) {
            System.out.println("跳舞" + i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("跳完了");
    }
}

class MThread1 extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 100; i++) {
            System.out.println("唱歌" + i);
            try {
                sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("唱完了");
    }
}

class MThread2 extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 100; i++) {
            System.out.println("打篮球" + i);
            try {
                sleep(70);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("打完了");
    }
}

线程同步线程安全问题

卖票案例

案例需求

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

实现步骤

1定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100; 表示票的数量
2 在SellTicket类中重写run()方法实现卖票，代码步骤如下
- 添加死循环，表示一直在买票
- 判断票数大于0，就卖票，并告知是哪个窗口卖的
- 卖了票之后，总票数要减1
- 票数小于等于0，线程停止
3 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
- 创建SellTicket类的对象
- 创建三个Thread类的对象，给线程定义名字为窗口1、窗口2、窗口3，把SellTicket对象作为构造方法的参数分别传给三个线程对象。
4启动3个线程

代码

注意：
- 代码中有三个线程对象，Runnable对象只有一个

public class SellTicket implements Runnable {
    private int tickets = 100;
    //在SellTicket类中重写run()方法实现卖票，代码步骤如下
    @Override
    public void run() {
        while (true) {
            if(ticket <= 0){
                    //判断ticket数量小于等于0，说明卖完了，结束循环
                    break;
                }else{
                    try {
                        Thread.sleep(100);//模拟卖票消耗100ms
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;//卖票 导致数量-1
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                }
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        //创建SellTicket类的对象
        SellTicket st = new SellTicket();

        //创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

卖票案例的问题【理解】

卖票出现了问题
- 相同的票出现了多次
- 出现了负数的票
问题产生原因
- 多个线程执行的随机性导致的,可能在卖票过程中丢失cpu的执行权,导致出现问题

1同步代码块解决数据安全问题

安全问题出现的条件
- 是多线程环境
- 有共享数据，比如上面案例中的票的数量
- 有多条语句操作共享数据
如何解决多线程安全问题呢?
- 基本思想：让程序没有安全问题的环境
怎么实现呢?
- 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
- Java提供了同步代码块的方式来解决
同步代码块格式：

synchronized(任意对象) { 
	多条语句操作共享数据的代码 
}

synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
- 多个线程操作同一个代码块，要保证对象锁是同一个。

代码

注意是操作共享数据的那块代码放到同步代码块中

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) { // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
                //t1进来后，就会把这段代码给锁起来
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                        //t1休息100毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //窗口1正在出售第100张票
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--; //tickets = 99;
                }
            }
            //t1出来了，这段代码的锁就被释放了
        }
    }
}

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

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

同步的好处和弊端

好处：解决了多线程的数据安全问题
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
大家可以了解下 hashmap和hashtable的区别

代码的原子性

原子性：操作要么不间断地全部被执行，不受任何打扰，要么一个也没有执行
num++是非原子性操作，本质是3步完成
- 1获取num的值
- 2把num的值做+1计算
- 3 把计算后的值赋值给num

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

        A a = new A();

        Thread t4 = new Thread(a);
        Thread t5 = new Thread(a);
        //Thread t6 = new Thread(a);

        t4.start();
        t5.start();
        //t6.start();
    }
}


class A implements Runnable {
    private int num = 0;

    //在SellTicket类中重写run()方法实现卖票，代码步骤如下
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            synchronized (this) {
                num++;
            }
        }
        System.out.println("num=" + num);
    }
}

图解

在这里插入图片描述

同步方法解决数据安全问题

同步方法的格式

同步方法：就是把synchronized关键字加到方法上

修饰符 synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}

同步方法的锁对象是什么呢? 是 this

静态同步方法（了解）

同步静态方法：就是把synchronized关键字加到静态方法上

修饰符 static synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}

同步静态方法的锁对象是什么呢? 是类名.class

代码

public class MyRunnable implements Runnable {
    private int ticketCount = 100;

     @Override
    public void run() {
        while (true) {
            //调用sell方法卖票  sell方法是一个同步方法
            boolean isBreak = sell();
            if (isBreak) { //根据sell的返回值 决定是否结束循环
                break;
            }
        }
    }

    public synchronized boolean sell() {
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出一张电影票");
            try {
                //模拟卖票耗时
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            tickets--;
            System.out.println("还剩" + tickets + "张");
            return false;
        } else {
            return true;
        }
    }
}

测试代码

这里两个线程，都行mr对象的里的任务
一个使用同步代码块，一个使用同步方法
- 这里同步代码块和同步方法的锁都是this，也就是当前的runnable对象mr

public class Demo {

      public static void main(String[] args) {

          MyRunnable mr = new MyRunnable();

          Thread t1 = new Thread(mr);
          Thread t2 = new Thread(mr);
    
          t1.setName("窗口一");
          t2.setName("窗口二");
    
          t1.start();
          t2.start();
      }

  }

演示同步方法的锁是this的代码

下面代码窗口1线程用同步方法窗口2线程用同步代码块
同步代码块的锁只有用this的时候, 最终结果是对象的 ,说明窗口1的同步方法的锁是this

package com.heima.test9;

public class SellTicket implements Runnable {

    //总数量
    private int tickets = 10000;
    Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            //获取线程的名字
            String threadName = Thread.currentThread().getName();
            //判断 是窗口1还是窗口2
            if (threadName.equals("窗口1")) {
                //调用sell方法卖票  sell方法是一个同步方法
                boolean isBreak = sell();
                if (isBreak) { //根据sell的返回值 决定是否结束循环
                    break;
                }
            } else {
                synchronized (this) {
                    if (tickets > 0) {
                        System.out.println(Thread.currentThread().getName() + "卖出一张电影票");
                        //try {
                        //    //模拟卖票耗时
                        //    Thread.sleep(10);
                        //} catch (InterruptedException e) {
                        //    e.printStackTrace();
                        //}
                        tickets--;
                        System.out.println("还剩" + tickets + "张");
                    } else {
                        break;
                    }
                }
            }
        }
    }

    //sell用synchronized修饰 为一个同步方法
    public synchronized boolean sell() {
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出一张电影票");
            //try {
            //    //模拟卖票耗时
            //    Thread.sleep(10);
            //} catch (InterruptedException e) {
            //    e.printStackTrace();
            //}
            tickets--;
            System.out.println("还剩" + tickets + "张");
            return false;
        } else {
            return true;
        }
    }

}

测试

public static void main(String[] args) {
    SellTicket sellTicket = new SellTicket();

    new Thread(sellTicket,"窗口1").start();
    new Thread(sellTicket,"窗口2").start();
}

Lock锁 Reentrant rɪˈentrənt

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
ReentrantLock构造方法

方法名说明
ReentrantLock() 创建一个ReentrantLock的实例
加锁解锁方法

方法名说明
void lock() 获得锁
void unlock() 释放锁

方法名	说明
ReentrantLock()	创建一个ReentrantLock的实例

方法名	说明
void lock()	获得锁
void unlock()	释放锁

代码

lock.lock()加锁
释放锁lock.unlock(); 一般写在finally中保证正常执行

  public class Ticket implements Runnable {
      //票的数量
      private int ticket = 100;
      private ReentrantLock lock = new ReentrantLock();

      @Override
      public void run() {
          while (true) {
==
              try {
                  lock.lock();//加锁
                  if (ticket <= 0) {
                      //卖完了
                      break;
                  } else {
                      Thread.sleep(100);
                      ticket--;
                      System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                  }
              } catch (InterruptedException e) {
                  e.printStackTrace();
              } finally {
                  lock.unlock();//释放锁
              }
          }
      }
  }

  public class Demo {
      public static void main(String[] args) {
          Ticket ticket = new Ticket();

          Thread t1 = new Thread(ticket);
          Thread t2 = new Thread(ticket);
          Thread t3 = new Thread(ticket);

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

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

死锁

在一个锁里嵌套添加另外一个锁
当多线程时，导致都卡到两个锁的中间，程序停滞处于等待状态

    public static void main(String[] args) {
        Object objA = new Object();
        Object objB = new Object();

        new Thread(()->{
            while(true){
                synchronized (objA){
                    //线程一
                    System.out.println("小康进入a");
                    synchronized (objB){
                        System.out.println("小康进入b");
                        System.out.println("小康同学正在走路");
                    }
                }
            }
        }).start();

        new Thread(()->{
            while(true){
                synchronized (objB){
                    //线程二
                    System.out.println("小薇进入B");
                    synchronized (objA){
                        System.out.println("小薇进入A");
                        System.out.println("小薇同学正在走路");
                    }
                }
            }
        }).start();
    }