线程执行任务给run方法加锁结果演示以及解决并发死循环问题的内容总结

文章目录

线程加锁,解决并发死循环问题的内容总结

---

---

前言

例如：在一个时间段内一次执行操作.例如卖票,抢购,秒杀看似同时进行,
实际是一个一个执行,但是一个个执行如果两次执行恰好同时进行,那就会对共享资源引起冲突。所以引入线程“同步”机制，即各线程间要有先来后到的执行顺序,本文就对其加锁中一些小问题总结一下
(注意考虑 继承Thread 与 实现Runnable接口的问题)

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、给Run方法加锁造成什么

这里考虑买票问题例子

1.继承方式的加锁

package com.jwq.javathread.demo6;

public class TicketThread extends Thread{

    static int ticket = 10;//static修饰后对象就会共享一个ticket变量

    @Override
    public void run() {
            while(true){
                if(ticket<=0){
                    break;
                }
                printTicket();
            }
        }
        /*
        这里的synchronized锁对象默认是该类的.class对象
        可以这样认为每个类本来就有一个class对象(没创建新对象前)
        */
        public synchronized static void printTicket(){
        if(ticket>0){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
                System.out.println(Thread.currentThread().getName()+": 卖出第 "+ticket--+"张票");
        }
    }

●这个例子里,如果锁加给run方法会咋样呢?

因为到时候要new两个该TicketThread对象,两次线程的run方法通过各自的对象分别运行,起不到加锁的作用

2.实现RUnnable接口给run方法加锁

package com.jwq.javathread.demo7;

public class TicketThread implements Runnable{
    public int ticket = 10;
    /*
    这里不用给ticket加static因为,实现Runnable方式,是创建线程任务,将任务抛进线程对象里,演示在下面
    */
    @Override
    public void run() {
        while(true){
            synchronized (this){//这里的锁对象是该对象自己,因为只有一份
                if(ticket>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+" 已经卖出第"+ticket--+"张");
                }else break;
            }
        }
    }

将任务抛进线程对象演示代码

package com.jwq.javathread.demo7;
public class Test {
public static void main(String[] args) {
TicketThread ticketThread = new TicketThread();//创建一个任务对象
Thread thread1 = new Thread(ticketThread,“窗口1”);//分别抛进两个线程,并且起名字
Thread thread2 = new Thread(ticketThread,“窗口2”);
thread1.start();
thread2.start();
}
}

●这个例子里,如果锁加给run方法会咋样呢?

因为到时候要new一个TicketThread任务对象,两次线程的run方法通过各自的对象分别运行同一个任务对象里的run方法,会起到线程先后,就可以发挥锁的作用

二、线程通信打印0~~100的问题

1.交替打印会死循环

代码如下（示例）：两个线程交替打印0到100

package com.jwq.javathread.demo10;

public class SpeakThread implements Runnable{
    int n=0;
    @Override
    public synchronized void run() {

        while(true){
            if(n<100){
                this.notify();//唤醒之前的线程
                System.out.println(Thread.currentThread().getName()+" : "+(++n));
            }else{
                break;
            }
            try {
                this.wait();//当执行完当前打印工作后就进入阻塞阶段(可以先看一下线程状态),等待苏醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程状态了解 :点击这里

这样的结果会导致代码不下来,上图

这是因为你的 this.notify() 唤醒之前等待线程加入到了条件小于100里面,这样就会导致当线程1运行到了99这一次时,唤醒之前的线程2,来打印100这次,并且this.notify()唤醒之前的线程1,当线程1执行时就发现已经不满足条件了,所以也就叫不醒之前的线程2,导致程序一致运行,停不下来

2.交替打印会死循解决原因

如果将this.notify()放到小于100条件的外面就会,每次唤醒之前的线程,让程序运行完毕

代码如下

package com.jwq.javathread.demo10;

public class SpeakThread implements Runnable{
    int n=0;
    @Override
    public synchronized void run() {

        while(true){
            this.notify();//放到条件的外面,唤醒并且结束之前的线程
            if(n<100){
                System.out.println(Thread.currentThread().getName()+" : "+(++n));
            }else{
                break;
            }
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

给看官大佬附图

这样就解决了线程关不掉的死循环的问题

---

总结

简要说了一下,给线程任务里的run方法加锁的结果,和线程通信的交替打印小问题