JavaSE基础(十一 )--＜线程＞线程同步,死锁,Lock锁,线程通信,生产消费问题,新增的线程创建方式

Posted 2021-06-15 小智RE0

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaSE基础(十一 )--＜线程＞线程同步,死锁,Lock锁,线程通信,生产消费问题,新增的线程创建方式相关的知识，希望对你有一定的参考价值。

1.线程同步

线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多，临界区对象就是其中一种。
在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。但是多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。
同步就是协同步调，按预定的先后次序进行运行。如：你说完，我再说。
“同”字从字面上容易理解为一起动作
其实不是，“同”字应是指协同、协助、互相配合。
如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B执行，再将结果给A；A再继续操作。
所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法。按照这个定义，其实绝大多数函数都是同步调用（例如sin, isdigit等）。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。例如Window API函数SendMessage。该函数发送一个消息给某个窗口，在对方处理完消息之前，这个函数不返回。当对方处理完毕以后，该函数才把消息处理函数所返回的LRESULT值返回给调用者。

线程同步的前提

(1)多线程状况下;
(2)多个线程去访问同一个资源.

并发和并行:
并行：多个CPU同时执行多个任务。(多个人同时做不同的事).
并发:一个CPU（采用时间片）同时执行多个任务。(多个人做同一件事).

同步的机制: 排队并且加锁

(1)几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作；

(2)为了保证数据在方法中被访问时的正确性，在访问时加入锁机制.

对于初步模拟火车售票:

使用两种创建线程的方式进行比较;

(1)继承Thread类的方式.

ThreadTicket01类模拟;

//模拟售票
public class ThreadTicket01 extends Thread {
    //将车票作为共享资源;
    static int ticketNum=10;
    //重写run方法;
    @Override
    public void run() {
        while(true) {
            if (ticketNum > 0) {
                //设置进入阻塞状态;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //售出票;
                System.out.println(Thread.currentThread().getName()+"->"+ticketNum);
                ticketNum--;
            } else {
                break;
            }
        }
    }
}

这里的车票用static修饰,全局共享一份资源.

被static修饰的变量;随着类的加载而加载.生命周期比较长
非static 修饰变量;生命周期与对象相同

测试类:

public class Test1 {
    public static void main(String[] args) {
        //创建线程1;
        ThreadTicket01 t1=new ThreadTicket01();
        t1.setName("售票窗口1号");//为线程1设置名称;
        //启动线程1;
        t1.start();
        //创建线程2;
        ThreadTicket01 t2=new ThreadTicket01();
        t2.setName("售票窗口2号");//为线程2设置名称;
        //启动线程2;
        t2.start();
    }
}

输出结果时:有时会出现同一张票被重复卖出两次或者卖出空票的状况;显然这是不合理的;线程刚失去CPU的执行权,走出运行状态,返回到就绪状态;又再一次获得执行权.

在这里插入图片描述

(2)实现Runnable的方式

在这个方式中,多个线程访问了同一个接口的对象,所以车票本身就只有一份,是被共享的,不需要static修饰;
出票的ThreadTicket02类:

//模拟售票
public class ThreadTicket02 implements Runnable{
    //在这个方式中,多个线程访问了同一个接口的对象,所以车票本身就只有一份,是被共享的,不需要static修饰;
    int ticketNum=10;
    //重写run方法;
    @Override
    public void run() {
        while(true){
            if(ticketNum>0){
                //设置进入阻塞状态;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //出票;
                System.out.println(Thread.currentThread().getName()+"->"+ticketNum);
                ticketNum--;
            }else{
                break;
            }
        }
    }
}

测试类:

public class Tese2 {
    public static void main(String[] args) {
        //这里只是创建了一个线程执行的任务;
        ThreadTicket02 tt=new ThreadTicket02();
        //创建线程1;
        Thread t1=new Thread(tt,"售票窗口1号");
        //启动线程1;
        t1.start();

        //创建线程2;
        Thread t2=new Thread(tt,"售票窗口2号");
        //启动线程2;
        t2.start();
    }
}

同样的,这时的售票也会出现卖出同一张票的情况;

在这里插入图片描述

加锁机制

确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁，哪个线程获取了这把锁，才有权利访问该共享资源。

可以理解为银行自助取款机的机制,当第一个人进入后,自动上锁;第二个想要进入时发现上锁了,只能等第一个人操作结束,解锁出来后才可以进入取款机操作.

在Java代码中实现线程同步：

使用synchronized(同步监视器)关键字同步代码块。
synchronized (同步监视器）{
// 需要被同步的代码；
}
synchronized还可以放在方法声明中，表示整个方法为同步方法。
例如：
public synchronized void show (String name){
// 需要被同步的代码；
}

同步监视器

同步监视器可以是任何对象,必须唯一,保证多个线程获得是同一个对象(锁).

同步监视器的执行过程:

第一个线程访问，锁定同步监视器，执行其中代码.
第二个线程访问，发现同步监视器被锁定，无法访问.
第一个线程访问完毕，解锁同步监视器.
第二个线程访问，发现同步监视器没有锁，然后锁定并访问.

使用关键字synchronized (同步监视器）加锁后模拟刚才的火车售票

(1)继承了Thread类的售票方式

使用synchronized(同步监视器)关键字同步代码块。

在刚才的基础上加锁;注意,这里加同步监视器时,不是写在while循环外面;若写到while循环外,则会出现一个线程持续操作,将所有票买完;
为需要同步的代码块,用关键字synchronized (同步监视器)同步代码块修饰;多个线程共同拥有一把锁;谁先获得则先进入,执行任务;其他的线程等待;当持有锁的线程将同步代码块中的内容都执行完后,离开同步代码块,自动释放锁.

//模拟售票
public class ThreadTicket01 extends Thread {
    //将车票作为共享资源;
    static int ticketNum=10;
    //这里使得线程获得的是一个对象(锁);
    //这里仍然用static修饰为全局共享的;
    static Object object=new Object();
    @Override
    public void run() {
        //注意,这里加同步监视器时,不是写在while循环外面;若写到while循环外,则会出现一个线程持续操作,将所有票买完;
        while(true) {
            //为需要同步的代码块,用同步代码块修饰;多个线程共同拥有一把锁;谁先获得则先进入,执行任务;其他的线程等待;当持有锁的线程将同步代码块中的内容都执行完后,离开同步代码块,自动释放锁;
            synchronized (object) {
                if (ticketNum > 0) {
                    //设置进入阻塞状态;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //售出票;
                    System.out.println(Thread.currentThread().getName() + "->" + ticketNum);
                    ticketNum--;
                } else {
                    break;
                }
            }
        }
    }
}

测试类不变;执行后,并没有出现卖出重复的票或者错误的票的情况;

在这里插入图片描述

synchronized还可以放在方法声明中，表示整个方法为同步方法。

synchronized修饰方法时,没有创建共享的锁对象;

注意在继承Thread类的方式创建线程时,是创建了多个线程对象,如果没有用static修饰这里的同步方法时,锁对象默认为this;就会出现多个线程拥有多把锁,执行任务时混乱.
所以在继承Thread类的创建线程的方式,需要使用static修饰同步方法.

public class ThreadTicked03 extends Thread{
    //将车票作为共享资源;
    static int ticketNum=10;
    //重写run方法;
    @Override
    public void run() {
        //这里仍然使用死循环;
        while(true){
            if(ticketNum>0){
                printTicket();
            }else {
                break;
            }
        }
    }
    //使用synchronized修饰方法;该方法为同步方法;
    //注意这里用static将方法变为全局共享的同一份方法;
    public static synchronized void printTicket(){
        if (ticketNum > 0) {
            //设置进入阻塞状态;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //售出票;
            System.out.println(Thread.currentThread().getName() + "->" + ticketNum);
            ticketNum--;
        }
    }
}

(2)实现Runnable类的售票方式

使用synchronized(同步监视器)关键字同步代码块。

在刚才实现Runnable类的基础上加锁;注意这里在新建锁对象时不需要使用static修饰;

实现Runnable创建线程的方式;只是创建了一个任务,让创建出的多个线程去执行这个任务.

//模拟售票
public class ThreadTicket02 implements Runnable{
    //在这个方式中,多个线程访问了同一个接口的对象,所以车票本身就只有一份,是被共享的,不需要static修饰;
    int ticketNum=10;
    //创建锁对象;
    Object object=new Object();
    //重写run方法;
    @Override
    public void run() {
        while(true){
            //使用synchronized同步代码块;
            synchronized (object) {
                if (ticketNum > 0) {
                    //设置进入阻塞状态;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //出票;
                    System.out.println(Thread.currentThread().getName() + "->" + ticketNum);
                    ticketNum--;
                } else {
                    break;
                }
            }
        }
    }
}

在这里插入图片描述

synchronized还可以放在方法声明中，表示整个方法,为同步方法。

这里的同步方法不需要static修饰.

public class ThreadTicket04 implements Runnable {
    //在这个方式中,多个线程访问了同一个接口的对象,所以车票本身就只有一份,是被共享的,不需要static修饰;
    int ticketNum=10;
    //重写run方法
    @Override
    public void run() {
        //while循环;
        while (true) {
            if (ticketNum > 0) {
                printTicket();
            } else {
                break;
            }
        }
    }
    //使用synchronized修饰方法,为同步方法;
    public synchronized void printTicket(){
        if (ticketNum > 0) {
            //设置进入阻塞状态;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //出票;
            System.out.println(Thread.currentThread().getName() + "->" + ticketNum);
            ticketNum--;
        }
    }
}

死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
一种情形，此时执行程序中两个或多个进程发生永久堵塞（等待），每个进程都在等待被其他进程占用并堵塞了的资源。例如，如果进程A锁住了记录1并等待记录2，而进程B锁住了记录2并等待记录1，这样两个进程就发生了死锁现象。

一个线程持有锁时会导致其他所有需要此锁的线程挂起；在多线程模式下，加锁/释放锁会导致比较多的上下文切换和调度延时，引起性能问题.

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁.
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续.

不同的线程相互持有对方线程中需要的锁,死锁出现不会报错,不会提示,只是等待.

模拟死锁

//模拟死锁
public class Demo01 extends Thread{
    //定义两个锁对象;
    static Object object1=new Object();
    static Object object2=new Object();
    //定义一个标记符;
    boolean flag=true;
    //构造方法;
    public Demo01(Boolean flag){
        this.flag=flag;
    }
    //重写run方法;
    @Override
    public void run() {
        //线程对象传入的flag参数进行分流执行;
        if(flag){
            synchronized (object1){
                System.out.println("if 1号锁");
                synchronized (object2){
                    System.out.println("if 2号锁");
                }
            }
        }else{
            synchronized (object2){
                System.out.println("else 2号锁");
                synchronized (object1){
                    System.out.println("else 1号锁");
                }
            }
        }
    }
}

测试类:

public class Test {
    public static void main(String[] args) {
        //创建线程1,线程2;
        Demo01 demo01=new Demo01(true);
        Demo01 demo02=new Demo01(false);
        //启动线程1,线程2;
        demo01.start();
        demo02.start();
    }
}

执行,可能会出现死锁现象:例如:
线程一直处于阻塞状态;

当第一个线程进入后,拿到了1号锁;第二个线程进入后拿到了2号锁,但是,这时第一个线程还想继续执行同步代码块中的内容;却获得不到2号锁;第二个线程想要继续执行同步代码块中的内容;由于1号锁被第一个线程拿着;没法获取1号锁.;;所以出现了死锁的状况;既没有异常提示,也没有提示,只是在阻塞状态中等待.

在这里插入图片描述

死锁解决方式

在系统中已经出现死锁后，应该及时检测到死锁的发生，并采取适当的措施来解除死锁。
死锁预防
这是一种较简单和直观的事先预防的方法。方法是通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。预防死锁是一种较易实现的方法，已被广泛使用。但是由于所施加的限制条件往往太严格，可能会导致系统资源利用率和系统吞吐量降低。
死锁避免
系统对进程发出的每一个系统能够满足的资源申请进行动态检查，并根据检查结果决定是否分配资源；如果分配后系统可能发生死锁，则不予分配，否则予以分配。这是一种保证系统不进入死锁状态的动态策略。
死锁检测和解除
先检测：这种方法并不须事先采取任何限制性措施，也不必检查系统是否已经进入不安全区，此方法允许系统在运行过程中发生死锁。但可通过系统所设置的检测机构，及时地检测出死锁的发生，并精确地确定与死锁有关的进程和资源。检测方法包括定时检测、效率低时检测、进程等待时检测等。
然后解除死锁：采取适当措施，从系统中将已发生的死锁清除掉。
这是与检测死锁相配套的一种措施。当检测到系统中已发生死锁时，须将进程从死锁状态中解脱出来。常用的实施方法是撤销或挂起一些进程，以便回收一些资源，再将这些资源分配给已处于阻塞状态的进程，使之转为就绪状态，以继续运行。死锁的检测和解除措施，有可能使系统获得较好的资源利用率和吞吐量，但在实现上难度也最大。

让程序每次至多只能获得一个锁。当然，在多线程环境下，这种情况通常并不现实。
设计时考虑清楚锁的顺序，尽量减少嵌套的加锁交互数量。

Lock锁

从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，常用.

Lock锁需要手动加锁,手动关闭锁;如果同步代码块中可能会出现异常,就可以在指定的位置进行关闭释放锁操作,避免异常恶化.

Lock锁的案例

使用方法public abstract void lock( ) 加锁;
使用方法public abstract void unlock( ) 关闭释放锁;

//模拟买票;使用Lock锁;
public class Demo extends Thread{
    //定义全局共享变量ticketNum;
    static int ticketNum=10;
    //定义全局共享的Lock锁对象;
    static Lock locks=new ReentrantLock();
    //重写run方法;
    @Override
    public void run() {
        while (true){
            try{
                //lock方法加锁;
                locks.lock();
                //设置休眠时间;进入阻塞状态;
                Thread.sleep(1000);
                if(ticketNum>0){
                    //这里获取当前线程引用的线程名;且售出车票;
                    System.out.println(Thread.currentThread().getName()+"->"+ticketNum);
                    ticketNum--;
                }else{
                    break;
                }
            }catch (Exception e){
                //打印异常信息;
                e.printStackTrace();
            }finally{
                //无论是否出现异常,都会手动关闭锁;
                //关闭释放锁;
                locks.unlock();
            }
        }
    }
}

测试类:

//Lock锁模拟买票的测试类
public class Test {
    public static void main(String[] args) {
        //创建线程1,线程2,并且命名;
        Demo d1=new Demo();
        d1.setName("1号窗");
        Demo d2=new Demo();
        d2.setName("2号窗");
        //启动线程1,线程2;
        d1.start();
        d2.start();
    }
}

效果:

在这里插入图片描述

Lock锁与synchronized的区别

lock锁是显示的锁,需要手动加锁,手动关闭释放;(可在指定的位置关闭锁);而synchronized是隐式的锁,当线程执行完同步代码块或者同步方法中的内容后,自动关闭.
lock锁只能同步代码块,而synchronized可以同步代码块,可以修饰方法为同步方法
使用lock锁时JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（lock是接口,有许多实现子类,常用的实现类为ReentrantLock).
在线程的执行优先级中:Lock >同步代码块（已经进入了方法体，分配了相
以上是关于JavaSE基础(十一 )--＜线程＞线程同步,死锁,Lock锁,线程通信,生产消费问题,新增的线程创建方式的主要内容，如果未能解决你的问题，请参考以下文章

多线程编程学习笔记——线程同步

JAVASE02-Unit010：多线程基础 TCP通信

实验十七线程同步控制

JavaSE：线程同步机制

JAVA多线程提高十:同步工具CyclicBarrier与CountDownLatch

Java基础学习第二十五天——多线程学习总结

JavaSE基础(十 一 )--＜线程＞线程同步,死锁,Lock锁,线程通信,生产消费问题,新增的线程创建方式

文章目录

1.线程同步

线程同步的前提

同步的机制: 排队并且加锁

对于初步模拟火车售票:

(1)继承Thread类的方式.

(2)实现Runnable的方式

加锁机制

同步监视器

使用关键字synchronized (同步监视器）加锁后模拟刚才的火车售票

(1)继承了Thread类的售票方式

(2)实现Runnable类的售票方式

死锁

模拟死锁

死锁解决方式

Lock锁

Lock锁的案例

Lock锁与synchronized的区别

JavaSE基础(十一 )--＜线程＞线程同步,死锁,Lock锁,线程通信,生产消费问题,新增的线程创建方式