一、线程的相关概念

  • 程序(program)

    是为了完成特定任务,用某种语言进行编写的一组指令的集合。简单的说:就是我们写的代码

  • 进程

    1、进程是指运行中的程序,比如我们使用QQ,就启动一个进程,操作系统就会为该进程分配内存空间。当我们使用迅雷,又启动了一个进程,操作系统将为迅雷分配新的内存空间

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

  • 线程

    1、线程是由进程创建的,是进程的一个实体

    2、一个进程可以拥有多个线程

  • 其他相关概念

    1、单线程:同一个时刻,只允许执行一个线程

    2、多线程:同一时刻,可以执行多个线程,比如:一个qq进程,可以打开多个聊天窗口,一个迅雷进程,可以同时下载多个文件

    3、并发:同一个时刻,多个任务交替执行,造成一种“貌似同时”的错觉,简单的说,单核cpu实现的多个任务就是并发

    4、并行:同一个时刻,多个任务同时执行。多核cpu可以实现并行。并发金和并行可以同时存在

二、线程的创建

1、继承Thread类,重写run()方法

类图关系

代码案例:

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        /**
         * 1、请编写一个程序,开启一个线程,该线程每隔一秒,在控制台输出“ hello,world!”
         * 2、对上题改进:当输出80次 ”hello,world“,结束该线程
         * 3、使用JConsole 监控线程执行情况,并画出程序示意图
         */
        //创建一个Cat对象,当做线程使用
        Cat cat = new Cat();
        cat.start();
        //说明:当main线程启动一个子线程时,也就是Thread-0子线程,主线程不会阻塞,会继续执行下面的方法
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程:" + Thread.currentThread().getName() + " 正在打印: 我是主线程");
            Thread.sleep(1000);
        }
    }
}
//继承 Thread 类
//1、当一个类继承了Thread,该类就可以当做线程使用
//2、一般我们会重写run方法,写上自己的逻辑
//3、run Thread类 实现了 Runnable 接口的run方法
class Cat extends Thread{
    int time = 0;
    //重写run方法
    @Override
    public void run() {
        while (time < 10){
            //线程名称
            System.out.println("线程名称:=====>"+Thread.currentThread().getName() + " 正在打印:====> hello world!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            time++;
        }
    }
}

1、当运行该程序时,就相当于启动了一个进程,

2、启动进程过后,就会马上进入这个主方法,也就是main方法,进入main方法,就是相当于开启了一个主线程,也就是进程里面开启了一个主线程(main线程)

3、在这个main主线程里面,new了一个Cat,因为这个Cat继承了Thread,所以是一个线程类,Cat调用 start() 方法,就是相当于在main主线程中又开启了一个新的线程,Cat线程

4、当main线程启动一个子线程时,也就是Thread-0子线程,主线程不会阻塞,会继续执行下面的方法,这时的主线程和子线程都是交互执行的

5、当主线程执行完并退出时,子线程还在运行,这样并不会造成这个进程的结束(这个进程也就是应用程序)

6、主线程可以开启多个子线程,子线程也可以开启多个子线程,当最后一个子线程结束后,整个进程才会退出

2、实现Runnable接口

说明:

1、java是单继承的,在某些情况下一个类可能已经继承了某个父类,这时在用继承Thread方法来创建线程显然是不可能了

2、java设计者们提供了另一个方式创建线程,就是通过实现Runnable接口来创建线程

代码案例:

三、start() 和 run()

run() 方法只是一个普通的方法,在main主方法中调用线程的 run() 方法,只会是等待被调用的线程的 run() 方法执行完后才会再执行下一行代码,没有真正的启动一个线程,线程类调用的 run() 方法所在的线程是主线程,也就是main线程

start() 才会真正的启动线程

源码:

//首先调用start方法
public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);

    boolean started = false;
    try {
        start0(); //这个方法才是真正的启动线程
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

真正实现多线程的是 start0() 这个方法

//start0()是一个 本地方法,是JVM进行调用,底层是c/c++
//真正实现多线程的是 start0() 这个方法,而不是 run() 方法
private native void start0();

原理图:

start() 方法调用 start0() 方法后,该线程并不一定会立马执行,只是将线程变成了可运行状态,具体什么时候执行,取决于CPU,由CPU统一调度。

静态代理测试代码:

public class Thread02 {
    public static void main(String[] args) {
        //编写程序,该程序每隔一秒,在控制台输出 “hi” ,当输出10次后,自动退出,请使用实现Runnable接口方式实现,这里是静态代理
        //Dog dog = new Dog();
        //创建一个 Thread 对象,把dog(实现了Runnable接口),放入new Thread(dog)

        //这里使用了一个设计模式,代理模式,静态代理
        //Thread t = new Thread(dog);
        //t.start();

        Tiger tiger = new Tiger();
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();
    }
}
//测试
class Animal {}
class Tiger extends Animal implements Runnable {

    int time = 0;

    @Override
    public void run() {
        while (time < 10){
            
            System.out.println("老虎叫了" + (++time) + "声");
        }
    }
}


//模拟代理模式
//可以将ThreadProxy看做一个代理类
//模拟了一个最简单的Thread类
class ThreadProxy implements Runnable {
    //属性,类型是 Runnable
    private Runnable target = null;

    @Override
    public void run() {
        if (target != null){
            target.run(); //动态绑定(运行类型是 Tiger)
        }
    }

    //创建一个构造器,将实现了Runnable对象传进来
    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    //实现start方法
    public void start(){
        //这个方法是真正实现了多线程的方法
        start0();
    }

    public void start0(){
        run();
    }
}


//通过实现 Runnable 接口实现线程类
class Dog implements Runnable{
    int time = 0;

    //重写run方法
    @Override
    public void run() {
        while (true) {
            System.out.println("hi" + (++time) + " 线程名称:" + Thread.currentThread().getName());

            try {
                //休眠1秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (time == 10){
                break;
            }
        }
    }
}

四、多线程执行

要求:

请编写一个 程序,创建两个线程,一个线程每隔一秒输出 “hello,world”,输出10次,一个线程每隔1秒输出 “hi”,输出5次,退出

public class Thread03 {
    public static void main(String[] args) {
        //主线程执行后,下面的子线程不会造成阻塞所以主线程执行完成后,直接结束
        //但是子线程还在运行,所以这个主进程还在运行,主线程结束并不会影响主进程的运行
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);

        thread1.start();
        thread2.start();
    }
}

//每隔一秒输出 “hello,world”,输出10次退出
class T1 implements Runnable{
    int time = 0;
    @Override
    public void run() {
        while (time < 10){
            System.out.println("hello,world " + (++time));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//每隔一秒输出 “hi”,输出5次退出
class T2 implements Runnable{
    int time = 0;
    @Override
    public void run() {
        while (time < 5){
            System.out.println("hi " + (++time));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

五、Thread 和 Runnable 的区别

1、从java的设计来看,通过继承Thread或者实现Runnable接口来创建线程本质没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口

底层都是通过 start()方法 去调用 start0()方法

2、实现Runnable接口方式更加适合多个线程共享一个资源的情况,并且避免了单继承的限制

理解:当创建了一个线程类,继承Runnable接口,那么可以开启两个线程进行去同时执行这个线程类,这样两个线程就可以共享一个资源

T1 t1 = new T1();
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t1);
thread1.start();
thread2.start();

六、模拟售票

public class SellTicket {
    public static void main(String[] args) {
        //Thread 测试
//        SellTicket01 s1 = new SellTicket01();
//        SellTicket01 s2 = new SellTicket01();
//        SellTicket01 s3 = new SellTicket01();

        //启动
//        s1.start();
//        s2.start();
//        s3.start();

        //Runnable 测试
        SellTicket02 sellTicket02 = new SellTicket02();
        //启动 操作的是同一个对象
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();

    }
}

//使用 Thread 方式   互斥同步的问题
class SellTicket01 extends Thread{
    //票数,让多个线程共享
    private static int ticketNum = 100;
    @Override
    public void run() {
        while (true){
            //如果卖完了,直接退出
            if (ticketNum <= 0){
                System.out.println("售票结束....");
                break;
            }
            //没卖完,休眠50毫秒继续卖
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() +
                    " 卖出了1张票,剩余票数 ===> " + (--ticketNum));
        }
    }
}

//通过 Runnable 接口实现
class SellTicket02 implements Runnable{
    //票数,让多个线程共享
    private int ticketNum = 100;

    @Override
    public void run() {
        while (true){
            //如果卖完了,直接退出
            if (ticketNum <= 0){
                System.out.println("售票结束....");
                break;
            }
            //没卖完,休眠50毫秒继续卖
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() +
                    " 卖出了1张票,剩余票数 ===> " + (--ticketNum));
        }
    }
}

出现的共同问题:

当出现三个线程共享一个资源(票数)
当票数只剩2张,当t1先进行判断时,发现还有2张票,但是在t1没有来得及进行售票操作时,t2进来,此时的票数在t1没有减去1张前,还有2张,就在t2和t1正在往下执行售票操作时,t3进来,判断发现票数还没有减去,还有2张,也就执行售票操作,最终导致的结果是t1和t2已经完成了售票操作,分别卖出1张,那么t3就没有票,但是也执行了售票操作,导致票数为负数,超过额定的票数

七、线程退出和中断

1、线程退出

基本说明:

1、当线程完成任务后,会自动退出

2、还可以通过使用变量来控制 run 方法退出的方式停止线程,即通知方式

示例代码:

要求:启动一个线程t,要求在main线程中去停止线程t

public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

        //如果希望main线程去终止t1这个线程,必须修改loop,让t1退出run方法,从而终止 t1 -> 通知方法
        //让main线程休眠5秒,再去通知t1子线程
        Thread.sleep(5000);
        t1.setLoop(false);
    }
}

class T extends Thread{
    int count = 0;
    //设置一个变量
    private boolean loop = true;

    //通过set方式修改 loop 的值,从而达到将 run 方法停止的目的
    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {
        while (loop){
            System.out.println("我是子线程 " + Thread.currentThread().getName() + (++count));

            try {
                //休眠50毫秒
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2、线程中断

线程中断就是将正在休眠的线程提前中断,打断线程休眠,将线程唤醒,打断的线程将会重新进入 while 循环,再次执行

public class ThreadInterrupt_ {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        //开启子线程
        a.start();
        //主线程打印5次 “hi”,中断子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }
        //中断子线程的休眠
        a.interrupt();
    }
}
//自定义线程类
class A extends Thread{
    @Override
    public void run() {
        while (true){
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称,如果设置了名称,就显示该名称,
                // 如果没有设置,就显示默认名称
                System.out.println(Thread.currentThread().getName() + " 吃包子~~~ " + i);
            }

            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~ ");
                Thread.sleep(200000);
            } catch (InterruptedException e) {
                // InterruptedException 中断异常
                //当线程执行到一个interrupt方法时,就会catch一个异常,可以加入自己的业务代码
                System.out.println(Thread.currentThread().getName() + " 被interrupt了~~~ ");
            }
        }
    }
}

八、线程的常用方法

1、基本方法

1、setName //设置线程名称,使之与参数name相同

2、getName //返回该线程的名称

3、start //使该线程开始执行;java虚拟机底层调用该线程的 start0() 方法

4、run //调用线程对象 run 方法

5、setPriority //更改线程优先级

6、getPriority //获取线程优先级

7、sleep //在执行的毫秒数内让当前正在执行的线程休眠(暂停执行)

8、interrupt //中断线程

需要注意的细节:

1、start 底层会创建新的线程,调用 run,run就是一个简单的方法调用,不会启动新线程

2、线程优先级的范围

3、interrupt,中断线程,但是并没有真正的结束线程。所以一般用于中断正在休眠的线程

4、sleep:线程的静态方法,使当前线程休眠

源码,优先级常量:

    /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1; //优先级最低

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5; //正常的优先级

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10; //优先级最高

示例代码:

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相关方法
        T t = new T();
        //设置线程名称 setName
        t.setName("猪八戒");
        //设置优先级
        t.setPriority(Thread.MIN_PRIORITY);
        //开启线程
        t.start();

        //输出线程名称
        System.out.println("线程名称:" + Thread.currentThread().getName());

        //主线程打印5次 “hi”,然后中断子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }
        //中断子线程的休眠
        t.interrupt();

    }
}

//自定义线程类
class T extends Thread{
    @Override
    public void run() {
        while (true){
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称,如果设置了名称,就显示该名称,
                // 如果没有设置,就显示默认名称
                System.out.println(Thread.currentThread().getName() + " 吃包子~~~ " + i);
            }

            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~ ");
                Thread.sleep(200000);
            } catch (InterruptedException e) {
                // InterruptedException 中断异常
                //当线程执行到一个interrupt方法时,就会catch一个异常,可以加入自己的业务代码
                System.out.println(Thread.currentThread().getName() + " 被interrupt了~~~ ");
            }
        }
    }
}

2、线程礼让和线程插队

1、yield:线程礼让。让出cpu,让其他线程执行,但礼让的时间不确定,所以也不一定礼让成功

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        B b = new B();
        b.start();
        //让主线程输出 20次 hi,每隔1秒
        for (int i = 0; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程输出 hi" + i);
            //判断主线程是否到了第5次,让子线程先执行,执行完成后,主线程再执行
            if (i == 4){
                //线程礼让,不一定成功,这是一个静态方法,让主线程先执行
               Thread.yield();
            }
        }
    }
}

//创建子线程
class B extends Thread{
    int time = 0;
    @Override
    public void run() {
        //让子线程循环输出20次 hello,每隔1秒
        while (true){
            if (time == 20){
                break;
            }
            try {
                System.out.println("子线程输出 hello " + (++time));
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2、join:线程插队。插队的线程一旦插队成功,则肯定先执行完插入的线程所有任务

案例:

创建一个子线程,每隔1s输出 hello ,输出20次,主线程每隔1s ,输出 hi,输出 20 次

要求:

两个线程同时执行,当主线程输出 5 次后,就让子线程运行完毕,主线程再继续

join代码示例:

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        B b = new B();
        b.start();
        //让主线程输出 20次 hi,每隔1秒
        for (int i = 0; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程输出 hi" + i);
            //判断主线程是否到了第5次,让子线程先执行,执行完成后,主线程再执行
            if (i == 4){
                //让子线程先执行
                //线程插队
                b.join();
            }
        }
    }
}

//创建子线程
class B extends Thread{
    int time = 0;
    @Override
    public void run() {
        //让子线程循环输出20次 hello,每隔1秒
        while (true){
            if (time == 20){
                break;
            }
            try {
                System.out.println("子线程输出 hello " + (++time));
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3、用户线程和守护线程

基本介绍:

1、用户线程:也叫做工作线程,当线程的任务执行完或者通知方式结束

2、守护线程:一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束

3、常见的守护线程:垃圾回收机制

制作一个守护线程:

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        //声明守护线程
        MyDeamonThread mt = new MyDeamonThread();

        //将子线程设置为守护线程
        //一旦所有的线程结束工作,那么守护线程也将会退出工作
        mt.setDaemon(true);

        //启动守护线程
        mt.start();
        
        //主线程循环
        for (int i = 0; i <= 10; i++) {
            Thread.sleep(1000);
            System.out.println("我是主线程,我正在工作...");
        }
    }
}
//线程类
class MyDeamonThread extends Thread{
    @Override
    public void run() {
        //等价于while循环,无限循环
        for (; ;){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是守护线程,我正在守护.....");
        }
    }
}

注意点:

需要将 mt.setDaemon(true) 在线程启动之前设置,否则就会抛出异常

九、线程的生命周期

官方文档的生命周期:

  • NEW

    尚未启动的线程处于此状态

  • RUNNABLE

    在java虚拟机中执行的线程处于此状态

  • BLOCKED

    被阻塞等待监视器锁定的线程处于此状态

  • WAITING

    在等待另一个线程执行特定动作的线程处于此状态

  • TIMED_WAITING

    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

  • TERMINATED

    已经退出的线程处于此状态

线程生命周期转换图:

说明:

1、当创建一个线程,也就是new一个线程出来过后,首先进入一个NEW状态,一旦调用了 start() 方法,就进入 Runnable状态(可运行状态),Runnable状态细化的话可分为两个状态,Ready状态(就绪状态)和 Running(运行状态)

2、线程是否被执行,还要取决于线程是否被调度器选中执行,一旦被调度器选中,那么就从Ready状态(就绪状态),那么线程就进入Running状态(运行状态),如果线程运行结束,那么就会进入Teminated状态(终止状态),相当于线程挂了

3、如果线程在 Runnable状态(可运行状态)调用了 Tread.sleep(time)、o.wait(time)、t.join(time)、LockSupport.parkNanos() 这些方法,就会进入TimeWaiting状态(超时等待状态),等待时间结束后在进入 Runnable状态(可运行状态)

4、如果线程在 Runnable状态(可运行状态)调用了 o.wait()、t.join()、LockSupport.park() 这些方法,那么就会进入 Waiting状态(等待状态),通过线程执行 o.notify()、o.notifyAll()、LockSupport.unpark() 这些方法重新进入 Runnable状态(可运行状态)

5、当线程在Runnable状态(可运行状态)要去获取一把锁或者进入一个同步代码块时,会先进入 Blocked 状态(阻塞状态),获取锁后才会重新进入Runnable状态(可运行状态),等待 Running

在官方文档中有6种状态,但是在Runnable状态(可运行状态)线程是否在运行,要取决于调度器,由内核的调度器来执行,因此还可再细分为 Ready状态(就绪状态)和 Running状态(运行状态)

实例代码:

public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        Td td = new Td();
        //线程启动前状态
        System.out.println(td.getName() + " 线程启动前的状态 " + td.getState());
        td.start();
        //循环线程启动后的状态
        //Thread.State.TERMINATED != td.getState() 判断当前线程状态是否为终止状态
        while (Thread.State.TERMINATED != td.getState()){
            //当线程状态不为终止状态,就打印线程的实时状态
            System.out.println(td.getName() + " 线程正在运行的状态 " + td.getState());
            Thread.sleep(500); //让主线程休眠再打印
        }
        //线程停止的状态
        System.out.println(td.getName() + " 线程停止的状态 " + td.getState());
    }
}
class Td extends Thread{
    @Override
    public void run() {
        while (true){
            for (int i = 0; i < 10; i++) {
                System.out.println("hi~ " + i);
                try {
                    //这里的休眠会让线程进入 超时等待状态 TIMED_WAITING
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //for循环结束后直接退出子线程
            break;
        }
    }
}

十、线程同步机制

说明:

1、在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完整性

2、也可以这里理解:线程同步,即当有一个线程对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作

同步实现具体方法 – synchronized

1、同步代码块,对象锁

synchronized(对象){ //得到对象的锁,才能操作同步代码
	//需要被同步代码
}

2、synchronized( 还可以放在方法声明中,表示整个方法为同步方法

public synchronized void method(String name){
	//需要被同步的代码
}

3、理解:当一个人去上厕所前,进入厕所要先关门,上完厕所出来后,把门打开才能让下一个人进去上厕所

4、使用 synchronized 解决售票问题

public class SellTicket {
    public static void main(String[] args) {
        SellTicket01 sk = new SellTicket01();
        new Thread(sk).start();
        new Thread(sk).start();
        new Thread(sk).start();
    }
}

//通过 Runnable 接口实现
class SellTicket01 implements Runnable{
    //票数,让多个线程共享
    private int ticketNum = 100;
    //控制while循环
    private boolean loop = true;

    //public synchronized void sell(){} 通过synchronized加上一把锁,那么这个方法就是一个同步方法,这时,这个锁是在this对象上(SellTicket01)
    public synchronized void sell(){ // 同步方法,在同一时刻,只能有一个线程来操作这个卖票方法
        //如果卖完了,直接退出
        if (ticketNum <= 0){
            System.out.println("售票结束....");
            loop = false;
            return;
        }
        //没卖完,休眠50毫秒继续卖
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName() +
                " 卖出了1张票,剩余票数 ===> " + (--ticketNum));
    }

    @Override
    public void run() {
        while (loop){
            sell(); //这个sell方法是一个同步方法
        }
    }
}

同步原理:

比如有三个线程 t1、t2、t3,刚开始会去争夺锁,锁在对象上,当 t1 抢到这把锁,进去操作相关的代码,当操作完后, t1 就会把这把锁放回去,然后再去与 t2、t3 争夺这把锁,synchronized 是一把非公平锁,每个线程都可以去争夺

十一、互斥锁

说明:

1、java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性

2、每个对象都对应于一个可称为 互斥锁 的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象

3、关键字 synchronized 来与对象的互斥锁联系。当某个对象用 synchronized 修饰时,表明该对象在任一时刻只能由一个线程访问

4、同步的局限性:导致程序的执行效率要降低

5、同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)

6、同步方法(静态的)的锁为当前类本身

//同步方法(静态的)的锁为当前类本身
//1、public synchronized static void method(){} 锁是加在 SellTicket01.class上的,因为这个method01是一个静态方法
public synchronized static void method01(){}
//2、如果是静态方法中,实现一个同步代码块,那么synchronized中就是这个类的 .class
public static void method02(){
    synchronized (SellTicket01.class){}
}

将锁加在代码块上:

public class SellTicket {
    public static void main(String[] args) {
        SellTicket01 sk = new SellTicket01();
        new Thread(sk).start();
        new Thread(sk).start();
        new Thread(sk).start();
    }
}

//通过 Runnable 接口实现
class SellTicket01 implements Runnable{
    //票数,让多个线程共享
    private int ticketNum = 100;
    //控制while循环
    private boolean loop = true;
    //可以用这个object替代当前synchronized中的this,因为这三个线程操作的都是同一个类
    //synchronized (object)
    Object object = new Object();

    //同步方法(静态的)的锁为当前类本身
    //1、public synchronized static void method(){} 锁是加在 SellTicket01.class上的,因为这个method01是一个静态方法
    public synchronized static void method01(){}
    //2、如果是静态方法中,实现一个同步代码块,那么synchronized中就是这个类的 .class
    public static void method02(){
        synchronized (SellTicket01.class){}
    }

    public void sell(){ // 同步方法,在同一时刻,只能有一个线程来操作这个卖票方法
        //同步代码块 synchronized
        synchronized (this){
            //如果卖完了,直接退出
            if (ticketNum <= 0){
                System.out.println("售票结束....");
                loop = false;
                return;
            }
            //没卖完,休眠50毫秒继续卖
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() +
                    " 卖出了1张票,剩余票数 ===> " + (--ticketNum));
        }
    }

    @Override
    public void run() {
        while (loop){
            sell(); //这个sell方法是一个同步方法
        }
    }
}

注意事项和细节:

1、同步方法如果没有使用 statis 修饰,默认锁的对象为 this

2、如果方法使用statis修饰,默认锁对象为 当前类.class

3、实现的落地步骤:

  • 需要分析上锁的代码
  • 选择同步代码块或同步方法
  • 要求多个线程的锁对象为同一个即可
/**
 * 当调用该线程时,肯定是如下场景
 * new SellTicket02().start()
 * new SellTicket02().start()
 * 这样这个同步所就无法实现,原因是每次都是 new 一个新的 SellTicket02
 * 而不是操作同一个SellTicket02对象,所以 this 的指向都是新的对象,无法锁住
 * 最后失效
 */
class SellTicket02 extends Thread{

    private static int ticketNum = 100; //多个线程共享

    public void method(){
        synchronized (this){
            System.out.println("hello-");
        }
    }

    @Override
    public void run() {
        super.run();
    }
}

十二、线程死锁

基本介绍:

多个线程都占用了对方的锁资源,但不肯相让,导致了死锁,在编程是一定要避免死锁的发生

发生死锁实例代码:

public class DeadLock_ {
    public static void main(String[] args) {
        //线程A启动
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程 ");
        //线程B启动
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程 ");

        A.start();
        B.start();
    }
}

class DeadLockDemo extends Thread{
    //为保证多线程情况下,共享一个 object对象,这里使用static修饰
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        /**
         * 业务逻辑分析
         * 1、如果flag为true,线程A 就会先持有 o1 这个对象锁,然后尝试去获取 o2 对象锁
         * 2、如果 线程A 得不到 o2 对象锁,就会进入 Blocked 状态(阻塞状态)
         * 3、如果flag为false,线程B 就会先得到 o2 这个对象锁,然后尝试获取 o1 对象锁
         * 4、如果 线程B 拿不到 o1 对象锁,就会进入 Blocked 状态(阻塞状态)
         */
        if (flag){
            synchronized (o1){ //synchronized加上对象互斥锁,下面就是同步对象
                System.out.println(Thread.currentThread().getName() + " 进入o1 ");
                synchronized (o2){
                    System.out.println(Thread.currentThread().getName() + " 进入o2 ");
                }
            }
        }else{
            synchronized (o2){
                System.out.println(Thread.currentThread().getName() + " 进入o3 ");
                synchronized (o1){
                    System.out.println(Thread.currentThread().getName() + " 进入o4 ");
                }
            }
        }
    }
}

十三、释放锁

基本介绍:

1、当线程的同步方法、同步代码块执行结束

2、当线程在同步代码块、同步方法中遇到 break、return

3、当线程在同步代码块、同步方法中出现未处理的 Error 或 Exception,导致异常结束

4、当线程在同步代码块、同步方法中执行了线程对象的 wait() 方法,当前线程暂停,并释放锁

下面的操作不会释放锁:

1、线程执行同步代码块或者同步方法时,程序调用 Thread.sleep()、Thread.yield() 方法暂停当前线程的执行,不会释放锁

2、线程执行同步代码块时,其他线程调用了该线程的 suspend() 方法将该线程挂起,该线程不会释放锁,提示:应尽量避免使用 suspend() 和 resume() 来控制线程,方法不再推荐使用

版权声明:本文为花椒蛋炒饭原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/hjdcf/p/16631365.html