23_Java中的多线程

Java中的多线程

了解进程：

进程：是正在运行的程序

​ 是系统进行资源分配和调用的独立单位

​ 每一个进程都有它自己的内存空间和系统资源

了解线程：

线程：是进程中的单个顺序控制流，是一条执行路径

​ 单线程：一个进程如果只有一条执行路径，则称为单线程程序

​ 多线程：一个进程如果有多条执行路径，则称为多线程程序

例子：

​ 电脑中的记事本：必须执行完一个操作后才能进行另外的操作（即不能同时进行）

​ 扫雷程序：一旦开始，游戏与时间记录便分别同时进行，直到游戏结束

一、实现多线程

1、使用Thread类来实现多线程：

方式一：

​ 定义一个类MyThread继承Thread类

​ 在创建的MyThread类中重写run()方法

​ 创建MyThread类的对象

​ 启动线程

两个小问题：

​ 为什么要重写run()方法？

​ 因为run()是用来封装被线程执行的代码

​ run()方法和start()方法的区别？

​ run()：封装线程执行的代码，直接调用，相当于普通方法的调用

​ start()：启动线程；然后由JVM调用此线程的run()方法

参考代码：

package com.itheima_01;
 
/*
方式一：
	定义一个类MyThread继承Thread类
	在创建的MyThread类中重写run()方法
	创建MyThread类的对象
	启动线程
 */
public class MyThreadDemo {
    public static void main(String[] args){
        //创建MyThread对象
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
 
//        my1.run();
//        my2.run();
 
        //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法。
        my1.start();
        my2.start();
    }
}

2、设置和获取线程名称：

Thread类中设置和获取线程名称的方法

​ void setName(String name)：将此线程的名称更改为等于参数name

​ String getName()：返回此线程的名称

如何获取main()方法所在的线程的名称？

​ public static Thread currentThread()：返回对当前正在执行的线程对象的引用

参考代码：

package com.itheima_02;
 
public class MyThread extends Thread{
 
    public MyThread(){}
 
    public MyThread(String name){
        super(name);    //通过子类带参构造方法来调用父类带参构造方法
    }
 
    @Override
    public void run(){
        for(int i = 0; i < 100; i++){
            //从输出结果来看 我们尽管没有传入参数也会有默认名称
            System.out.println(getName() + ":" + i);
        }
    }
}
 
/*
    private volatile String name;
 
    public Thread() {
        this(null, null, "Thread-" + nextThreadNum(), 0);
    }
    调用子类无参构造方法，会自动调用父类无参构造方法
 
    public Thread(String name) {
        this(null, null, name, 0);
    }
    利用子类带参构造方法来调用父类带参构造方法
 
    通过以下两个带参构造方法来给类中的name成员变量来赋值
    public Thread(ThreadGroup group, Runnable target, String name,
                  long stackSize) {
        this(group, target, name, stackSize, null, true);
    }
 
    private Thread(ThreadGroup g, Runnable target, String name,
                   long stackSize, AccessControlContext acc,
                   boolean inheritThreadLocals) {
                        this.name = name;
                   }
 
    //set方法用于设置线程名
    public final synchronized void setName(String name) {
        this.name = name;
    }
 
    //get方法用于获取线程名
    public final String getName() {
        return name;
    }
 
    //这个是默认名字编号的由来
    private static int threadInitNumber;    //0，1，2
    private static synchronized int nextThreadNum() {
        return threadInitNumber++;  //0，1...
    }
 
 */

package com.itheima_02;
/*
Thread类中设置和获取线程名称的方法
	void setName(String name)：将此线程的名称更改为等于参数name
	String getName()：返回此线程的名称
 */
public class MyThreadDemo extends Thread{
    public static void main(String[] args){
       /* MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
 
        //void setName(String name)：将此线程的名称更改为等于参数name
        my1.setName("高铁");
        my2.setName("飞机");*/
 
//        //使用带参构造方法来个线程取名
//        MyThread my1 = new MyThread("高铁");
//        MyThread my2 = new MyThread("飞机");
//
//        my1.start();
//        my2.start();
 
        //static Thread currentThread() 返回对当前正在执行的线程对象的引用。
        //打开注释可以看到main方法，main最先输出
        System.out.println(Thread.currentThread().getName());
    }
}

3、线程调度：

线程有两种调度模型：

​ 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片

​ 抢占式调度模型：优先让线程高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取CPU时间片相对多一些

Java使用的是抢占式调度模型

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

Thread类中设置和获取线程优先级的方法：

​ public final int getPriority()：返回此线程的优先级

​ public final void setPriority(int newPriority)：更改此线程的优先级

​ 线程默认优先级是5，线程优先级的范围是：1~10

​ 线程优先级仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果

参考代码：

package com.itheima_03;
 
public class ThreadPriority extends Thread{
    @Override
    public void run(){
        for(int i = 0; i < 100; i++){
            System.out.println(getName() + ":" + i);
        }
    }
}

package com.itheima_03;
/*
Thread类中设置和获取线程优先级的方法：
	public final int getPriority()：返回此线程的优先级
	public final void setPriority(int newPriority)：更改此线程的优先级
 */
public class ThreadPriorityDemo {
    public static void main(String[] args){
        //创建多线程对象
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriority();
        ThreadPriority tp3 = new ThreadPriority();
 
        //设置线程名
        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");
 
//        //public final int getPriority()：返回此线程的优先级
//        //从输出结果来看，这三个线程的优先级都是5
//        System.out.println(tp1.getPriority());
//        System.out.println(tp2.getPriority());
//        System.out.println(tp3.getPriority());
 
        //说明：线程优先级高只是获取CPU使用权限的几率高并不代表一定会是按优先级进行
        //public final void setPriority(int newPriority)：更改此线程的优先级
//        tp1.setPriority(10000); //IllegalArgumentException 说明优先级不在 MIN_PRIORITY到 MAX_PRIORITY范围内。
//        System.out.println(Thread.MAX_PRIORITY);    //可以看到 线程最高优先级是10
//        System.out.println(Thread.MIN_PRIORITY);    //线程最低优先级是1
 
        //设置正确的优先级
        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);
 
        //使用start()方法启动线程
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

4、线程控制：

方法名	说明
static void sleep(long millis)	使用当前正在执行的线程停留（暂停执行）指定的毫秒数
void join()	等待这个线程死亡
void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

sleep参考代码：

这里在run方法中使用sleep方法，使得每一个线程在获得CUP使用权限后都会暂停一秒，这样就会使得每一个线程的次数相较于均匀，只是每一次几个线程之间的先后顺序不同

package com.itheima_04;
 
public class ThreadSleep extends Thread{
    @Override
    public void run(){
        for(int i = 0; i < 100; i++){
            System.out.println(getName() + ":" + i);
            try {   //使用sleep方法后尽管还是在强但是由于距离上一次都间隔了一秒使得每一次三个都能输出一下（只是先后顺序不同）
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.itheima_04;
/*
 static void sleep(long millis)  使用当前正在执行的线程停留（暂停执行）指定的毫秒数
 */
public class ThreadSleepDemo {
    public static void main(String[] args) {
        //创建线程对象
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();
 
        //设置线程名称
        ts1.setName("曹操");
        ts2.setName("刘备");
        ts3.setName("孙权");
 
        //启动线程
        ts1.start();
        ts2.start();
        ts3.start();
    }
}

Join参考代码：

这里使用Join方法，可以使得其后的线程对象等待其死亡（即结束）后再执行

package com.itheima_04;
 
public class ThreadJoin extends Thread{
    @Override
    public void run(){
        for(int i = 0; i < 100; i++){
            System.out.println(getName() + ":" + i);
        }
    }
}

package com.itheima_04;
/*
void join()                     等待这个线程死亡
 */
public class ThreadJoinDemo {
    public static void main(String[] args) {
        Thread tj1 = new ThreadJoin();
        Thread tj2 = new ThreadJoin();
        Thread tj3 = new ThreadJoin();
 
        tj1.setName("康熙");
        tj2.setName("四阿哥");
        tj3.setName("八阿哥");
 
        tj1.start();
        //可以看到需要这个线程结束后，后面的线程才会执行
        try{
            tj1.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
 
        tj2.start();
        tj3.start();
    }
}

setDaemon参考代码：

currentThread()方法用于获取当前执行的线程（可以是main，此处正是将其命名为刘备）

setDaemon()方法用于设置守护线程

对于一个程序，当主线程结束后。程序中只有守护线程在运行时，Java虚拟机会尽快结束程序执行。

package com.itheima_04;
 
public class ThreadDaemon extends Thread{
    @Override
    public void run(){
        for(int i = 0; i < 100; i++){
            System.out.println(getName() + ":" + i);
        }
    }
}

package com.itheima_04;
/*
void setDaemon(boolean on)      将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
    即主线结束，只剩下守护线程时，会尽快退出程序
 */
public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();
 
        td1.setName("关羽");
        td2.setName("张飞");
 
        //设置主线程为刘备（当前正在执行的线程名为刘备）
        Thread.currentThread().setName("刘备");
 
        //设置守护线程
        td1.setDaemon(true);
        td2.setDaemon(true);
 
        td1.start();
        td2.start();
 
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

5、线程的生命周期：

6、多线程的实现方式二：

创建线程的另一种方法是声明一个实现Runnable接口的类。

​ 定义一个类MyRunnable实现Runnable接口

​ 在MyRunnable类中重写run()方法

​ 创建MyRunnable类对象

​ 创建Thread类对象，把MyRunnable对象作为构造方法的参数

​ 启动线程

多线程的实现方案有两种

​ 继承Thread类

​ 实现Runnable接口

相比较继承Thread类，实现Runnable接口的好处

​ 避免了Java单继承的局限性（即继承Thread后的多线程不能在继承其它类）

​ 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序代码、数据有效分离，较好的体现了面向对象的设计思想

参考代码：

package com.itheima_05;
//通过实现接口来 实现多线程可以让其再继承其它类
//同时由于其可以作为参数向 Thread的构造器传递，所以可以被多个Thread对象实现
public class MyRunnable implements Runnable{
    @Override
    public void run(){
        for(int i = 0; i < 100; i++){
            //因为这个类实现的是Runnable接口，并没有继承Thread类所以是不能直接使用Thread类中的方法的
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

package com.itheima_05;
/*
创建线程的另一种方法是声明一个实现Runnable接口的类。
	定义一个类MyRunnable实现Runnable接口
	在MyRunnable类中重写run()方法
	创建MyRunnable类对象
	创建Thread类对象，把MyRunnable对象作为构造方法的参数
	启动线程
 */
public class MyRunnableDemo {
    public static void main(String[] args){
        //创建MyRunnable类对象
        MyRunnable mr = new MyRunnable();
 
        //创建Thread类对象，把MyRunnable对象作为构造方法的参数
        //Thread(Runnable target)   参数为Runnable接口的构造方法
//        Thread th1 = new Thread(mr);
//        Thread th2 = new Thread(mr);
 
        //Thread(Runnable target, String name)  //参数为Runnalbe接口和对应线程名称
        Thread th1 = new Thread(mr, "高铁");
        Thread th2 = new Thread(mr, "飞机");
 
        //启动线程
        th1.start();
        th2.start();
    }
}

二、线程同步

案例：卖票：

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

package com.itheima_06;
 
public class SellTicket implements Runnable{
    private static int tickets = 100;   //表示有100张票
 
    @Override
    public void run(){
        while(true){
            if(tickets > 0){
                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                tickets--;
            }
        }
    }
}

package com.itheima_06;
 
public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket mr = new SellTicket();
 
        Thread th1 = new Thread(mr, "窗口一");
        Thread th2 = new Thread(mr, "窗口二");
        Thread th3 = new Thread(mr, "窗口三");
 
        th1.start();
        th2.start();
        th3.start();
    }
}

分析案例：

可以看到这样还是有问题的：三个同时售出了第一张票，还有出现负数问题？

package com.itheima_07;
 
public class SellTicket implements Runnable{
    private static int tickets = 100;   //表示有100张票
 
    @Override
    public void run(){
        //相同的票出现了多次
//        while(true){
//            //tickets = 100
//            //t1,t2,t3
//            //假设t1线程抢到CUP的执行权
//            if(tickets > 0){
//                //通过sleep()方法来模拟出票的时间
//                try {
//                    Thread.sleep(100);
//                    //t1线程休息100毫秒
//                    //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
//                    //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                //假设线程按照顺序醒过来
//                //t1抢到CPU的执行权，在控制台输出，窗口1正在出售第100张票
//                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//                //t2抢到了CPU的执行权，在控制台输出，窗口2正在出售第100张票
//                //t3抢到了CPU的执行权，在控制台输出，窗口3正在出售第100张票
//                tickets--;
//                //如果这三个线程还是按照顺序来，这里就执行了3次--操作，最终票就变成了97
//            }
//        }
 
        //出现了负数的情况
        while(true){
            //tickets = 1
            //t1,t2,t3
            //假设t1线程抢到CUP的执行权
            if(tickets > 0){
                //通过sleep()方法来模拟出票的时间
                try {
                    Thread.sleep(100);
                    //t1线程休息100毫秒
                    //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
                    //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //假设线程按照顺序醒过来
                //t1抢到了CPU的执行权，在控制台输出，窗口1正在出售第一张票
                //假设t1继续拥有CPU的执行权，就会执行ticket--;操作，tickets = 0;（此时尽管t1线程无法在继续进行，但是如果t2线程。。）
                //t2抢到了CPU的执行权，在控制台输出，窗口2正在出售第0张票
                //假设t2继续拥有CPU的执行权，就会执行ticket--;操作，tickets = -1;
                //t3抢到了CPU的执行权，在控制台输出，窗口3正在出售第-1张票
                //假设t3继续拥有CPU的执行权，就会执行ticket--;操作，tickets = -2;（此时三个线程都无法通过while条件）
                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                tickets--;
            }
        }
    }
}

package com.itheima_07;
/*
    卖票程序的思考
 */
public class SellTickDemo {
    public static void main(String[] args) {
        SellTicket mr = new SellTicket();
 
        Thread th1 = new Thread(mr, "窗口一");
        Thread th2 = new Thread(mr, "窗口二");
        Thread th3 = new Thread(mr, "窗口三");
 
        th1.start();
        th2.start();
        th3.start();
    }
}

1、解决前面说到的卖票问题：

为什么出现问题？（这也是我们判断多线程程序是否会有数据安全问题的标准）

​ 是否是多线程环境

​ 是否有共享数据

​ 是否有多条语句操作共享数据

如何解决多线程安全问题呢？

​ 基本方法：使得问题条件之一不符合

这里如何实现？

​ 其一：这里需要使用多线程，所以不从此处下手

​ 其二：这里三个窗口一共有100张票，数据需要共享

​ 所以我们从第三条下手：把多条语句操作共享数据的代码锁起来，让任意时刻只能有一个线程执行即可

​ 在Java中通过同步代码块的方式来解决

2、同步代码块：

锁多条语句操作共享数据，可以使用同步代码块实现

格式：

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

synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

同步的好处和弊端

​ 好处：解决了多线程的数据安全问题

​ 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

参考代码

package com.itheima_08;
/*
    添加了锁后，可以使得多个线程在操作共享性数据时
    只能先等前一个执行完毕后（即开锁后才能继续执行）
    这样就防止了前一个线程修改中，后一个线程就闯入的 （导致数据冲突）
 */
public class SellTicket implements Runnable{
    private static int tickets = 100;
    private Object object= new Object();    //把锁放到外面，使得三个数据被一把锁绑定，而不会乱操作共享数据
 
    @Override
    public void run(){
        while(true){
            //tickets = 100;
            //t1,t2,t3
            //假设t1抢到了CPU的代码执行权
            //假设t2抢到了CPU的执行权，但是此时发现了这个代码被锁上了，就只能等待
            synchronized(object){ //在此处放锁（直接在这个作用域创建对象），就是三把锁三个，没有锁在一起
                //t1进来后，就会把这段代码给锁起来
                if(tickets > 0){
                    try {
                        Thread.sleep(100);
                        //t1休息100毫秒
 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //t1苏醒，窗口1正在售票
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;  //tickets = 99;
                }
            }
            //t1出来了，这段代码的锁就被释放了
        }
    }
}

package com.itheima_08;
/*
    卖票案例的思考
 */
public class SellTicketDemo {
    public static void main(String[] args){
        SellTicket st = new SellTicket();
 
        Thread th1 = new Thread(st, "窗口一");
        Thread th2 = new Thread(st, "窗口二");
        Thread th3 = new Thread(st, "窗口三");
 
        th1.start();
        th2.start();
        th3.start();
    }
}

3、同步方法：

1、非静态同步方法：

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

格式

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

同步方法的锁对象是什么？

​ this

2、静态同步方法：

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

格式

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

同步静态方法的锁对象是什么呢？

​ 类名.class

参考代码：

注意：SellTicket类中之所以要使用if...else来执行，是因为这样可以将同步代码块和同步方法一起在一个多线程中展示，这样就便于演示同步方法对应的锁对象是哪个。（可以理解为将一把锁以同步代码块和同步方法的形式展现出来了）

package com.itheima_09;
 
public class SellTicket implements Runnable{
    private static int tickets = 100;   //在使用非静态方法调用时，没有添加static静态修饰符
    private Object obj = new Object();  //未使用同步方法的锁
    private int x = 0;
 
    @Override
    public void run(){
        while(true){
            if(x%2 == 0){
//                synchronized(obj){    //未使用同步方法时 使用的锁是obj类
//                synchronized(this){     //使用同步"非静态"方法后 使用的锁是this
                synchronized(SellTicket.class){ //对应的字节码文件对象（静态方法可以使用类名来调用）
                    if(tickets > 0){
                        try{
                            Thread.sleep(100);
                        }
                        catch(InterruptedException e){
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                        tickets--;
                    }
                }
            }
            else{
//                synchronized(obj){
//                    if(tickets > 0){
//                        try{
//                            Thread.sleep(100);
//                        }
//                        catch(InterruptedException e){
//                            e.printStackTrace();
//                        }
//                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//                        tickets--;
//                    }
//                }
                sellTicket();
            }
            x++;
        }
    }
 
//    private void sellTicket() {
//        synchronized(obj){
//            if(tickets > 0){
//                try{
//                    Thread.sleep(100);
//                }
//                catch(InterruptedException e){
//                    e.printStackTrace();
//                }
//                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//                tickets--;
//            }
//        }
//    }
 
    //同步非静态方法
//    private synchronized void sellTicket() {    //锁是this
//        if(tickets > 0){
//            try{
//                Thread.sleep(100);
//            }
//            catch(InterruptedException e){
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//            tickets--;
//        }
//    }
 
    //同步静态方法
    private static synchronized void sellTicket() {    //锁是 类.class
        if(tickets > 0){
            try{
                Thread.sleep(100);
            }
            catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
            tickets--;
        }
    }
}

package com.itheima_09;
 
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();
    }
}

4、线程安全的类：

即可以在多线程环境下使用的集合，但是现在基本有对应的Collections（集合操作类中的方法进行替代）

StringBuffer

​ 线程安全，可变的字符序列

​ 从版本JDK 5开始，被StringBuilder代替。通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为他不执行同步（即不使用多线程时推荐使用StringBuilder 反之使用StringBuffer）

Vector

从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework（集合体系）的成员。与新的集合实现不同，Vector被同步。如果不需要线程安全的实现，建议使用ArrayList代替Vector

Hashtable

该类实现了一个哈希表，他将键映射值。任何非null对象都可以作为键或者值

从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework（集合体系）的成员。与新的集合实现不同，Hashtable被同步。如果不需要线程安全的实现，建议使用HashMap代替Hashtable

参考代码：

package com.itheima_10;
 
import java.util.Vector;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.HashMap;
import java.util.Collections;
/*
线程安全的类：
StringBuffer
 
Vector
 
Hashtable
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //可以在多线程环境中使用：线程安全类
        StringBuffer sb = new StringBuffer();   //可以看到方法中基本都添加了synchronized
        StringBuilder sb2 = new StringBuilder();    //可以看到这个类中的方法没有添加synchronized关键字修饰
 
        Vector<String> vector = new Vector<String>();
        ArrayList<String> arrayList = new ArrayList<String>();
 
        Hashtable<String, String> hashtable = new Hashtable<String,String>();
        HashMap<String, String> hashMap = new HashMap<String,String>();
 
        //但是后被Collections中的“将线程不安全类转换为线程安全类”替代了
        //static <T> List<T> synchronizedList(List<T> list) 返回由指定列表支持的同步（线程安全）列表。
        Collections.synchronizedList(new ArrayList<String>());
 
        //同时还有Set 和 Map的
    }
}

5、Lock锁：

虽然我们可以理解同步代码块和同步方法都是使用了一个锁对象将多线程操作共有变量的代码进行上锁，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5后提供了一个新的锁对象Lock

Lock实现提供了比使用synchronized方法和语句可以获得更广泛的锁定操作

Lock中提供了获得锁和释放锁的方法

​ void lock()：获得锁

​ void unlock()：释放锁

Lock是接口不能实例化，这里采用它的实现类ReentrantLock来实例化

Reentrant Lock的构造方法

​ ReentrantLock()：创建一个ReentrantLockd的示例

注意：因为含有释放操作，为了防止语句执行异常时释放操作并没有执行，需要使用try...finally语句块来写获得和释放锁操作

参考代码：

package com.itheima_11;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
Lock中提供了获得锁和释放锁的方法
	void lock()：获得锁
	void unlock()：释放锁
 */
 
public class SellTicket implements Runnable{
    private static int tickets = 100;
    private Lock lock = new ReentrantLock();
 
    @Override
    public void run(){
        while(true){
            try{
                lock.lock();    //获得锁
                if(tickets > 0){
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
 
                    System.out.println(Thread.currentThread().getName() + "正在售第" + tickets + "张票");
                    tickets--;
                }
            }
            finally{    //防止语句异常停止而未释放锁
                lock.unlock();  //释放锁
            }
        }
    }
}

package com.itheima_11;
/*
    使用Lock接口实现同步
    Lock中提供了获得锁和释放锁的方法
	void lock()：获得锁
	void unlock()：释放锁
 */
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();
    }
}

三、生产者消费者

1、生产者消费者模式概述：

生产者消费者模式时一个十分经典的多线程协作模式，弄懂这个模式可以使得我们更好的理解多线程编程

所谓生产者消费问题，实际上主要是包含了两类线程：

​ 一类是生产者线程用于生产数据

​ 一类是消费者线程用于消费数据

为了了解生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

​ 生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

​ 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中

Object类的等待和唤醒方法：

方法名	说明
void wait()	导致当前线程等待，直到另一个线程调用该对象的notify()方法或者notifyAll()方法
void notify()	唤醒正在等待对象监视器的单个线程
void notifyAll()	唤醒正在等待对象监视器的所有线程

2、生产者和消费者案例：

生产者消费者案例中包含的类：

​ 奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作

​ 生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作

​ 消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作

​ 测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下

​ 1、创建奶香对象，这里是共享数据区域

​ 2、创建生产者对象，把奶香对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作

​ 3、创建消费者对象，把奶香对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作

​ 4、创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递

​ 5、启动线程

参考代码：

package com.itheima_12;
/*
    奶箱类
    使用了wait需要在同步代码块中，所以需要在方法中加入synchronized关键字
 */
public class Box {
    //定义一个成员变量，表示第x瓶奶
    private int milk;
    //定义一个成员变量，表示奶箱的状态
    private boolean state = false;
 
    //提供存储牛奶和获取牛奶的操作
    public synchronized void put(int milk) {
        //如果有牛奶，需要等待消费
        if(state){
            try{
                wait();
            }
            catch(InterruptedException e){
                e.printStackTrace();
            }
        }
        //此处没有使用else 是与wait方法有关（等待完后还是要执行下面语句）
        //如果没有就生产
        this.milk = milk;
        System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱");
 
        //生产完后
        state = true;
 
        //唤醒其它等待的线程
        notifyAll();
    }
 
    public synchronized void get(){
        //如果没有牛奶、“等待”生产
        if(!state){
            try{
                wait();
            }
            catch(InterruptedException e){
                e.printStackTrace();
            }
        }
 
        //如果有牛奶就消费牛奶
        System.out.println("用户拿到第" + this.milk + "瓶奶");
 
        //修改完毕之后，修改奶箱状态
        state = false;
 
        //唤醒其它等待的线程
        notifyAll();
    }
}

package com.itheima_12;
/*
    生产者类
 */
public class Producer implements Runnable{
    public Box b;
 
    public Producer(Box b){
        this.b = b;
    }
 
    @Override
    public void run(){
        for(int i = 1; i <= 20; i++){
            b.put(i);
        }
    }
}

package com.itheima_12;
/*
    消费者类
 */
public class Customer implements Runnable{
    private Box b;
 
    public Customer(Box b){
        this.b = b;
    }
 
    @Override
    public void run(){
        while(true){
            b.get();
        }
    }
}

package com.itheima_12;
/*
生产者消费者案例中包含的类：
	奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
	生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作
	消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作
	测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下
    			1、创建奶香对象，这里是共享数据区域
				2、创建生产者对象，把奶香对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
				3、创建消费者对象，把奶香对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
				4、创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
				5、启动线程
 */
public class BoxDemo {
    public static void main(String[] args){
        //创建奶箱对象，这里是共享数据区域
        Box b = new Box();
 
        //创建生产者对象，把奶香对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        Producer p = new Producer(b);
 
        //创建消费者对象，把奶香对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
        Customer c = new Customer(b);
 
        //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
 
        //启动线程
        t1.start();
        t2.start();
    }
}