乐趣区

关于java:Java多线程基础

作者：

jiezi

在

文章和代码曾经归档至【Github仓库：https://github.com/timerring/java-tutorial 】或者公众号【AIShareLab】回复 java 也可获取。

多线程根底

线程相干概念

程序(program)

是为实现特定工作、用某种语言编写的一组指令的汇合。简略的说:就是咱们写的代码。

过程

  1. 过程是指运行中的程序，比方咱们应用QQ，就启动了一个过程，操作系统就会为该过程分配内存空间。当咱们应用迅雷，又启动了一个过程，操作系统将为迅雷调配新的内存空间。
  2. 过程是程序的一次执行过程，或是正在运行的一个程序。是动静过程:有它本身的产生、存在和沦亡的过程

线程

  1. 线程由过程创立的，是过程的一个实体

  2. 一个过程能够领有多个线程,如下图

其余相干概念

  1. 单线程:同一个时刻,只容许执行一个线程。
  2. 多线程:同一个时刻,能够执行多个线程，比方:一个qq过程，能够同时打
    开多个聊天窗口,一个迅雷过程,能够同时下载多个文件。
  3. 并发:同一个时刻，多个工作交替执行，造成一种“貌似同时”的错觉，简略的说单核cpu实现的多任务就是并发。
  1. 并行:同一个时刻，多个工作同时执行。多核cpu能够实现并行。

获取cpu的数量/外围数

package com.hspedu;


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

        Runtime runtime = Runtime.getRuntime();
        //获取以后电脑的cpu数量/外围数
        int cpuNums = runtime.availableProcessors();
        System.out.println("以后有cpu 个数=" + cpuNums);
    }
}

线程根本应用

创立线程的两种形式

在java中线程来应用有两种办法。

1.继承Thread类，重写run办法

2.实现Runnable接口,重写run办法

线程利用案例1-继承Thread 类

运行程序时就相当启动了一个过程，进入main时就开启了一个main线程，

1)请编写程序,开启一个线程，该线程每隔1秒。在控制台输入“哺瞄。我是小猫咪

2)对上题改良:当输入80次啪瞄,我是小猫咪,完结该线程

3)应用JConsole 监控线程执行状况,并画出程序示意图!

在过程运行时间接在控制台输出JConsole即可。

主线程挂了然而子线程还在继续执行，这并不会导致应用程序的完结。阐明: 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行（不会等执行结束后再往下执行），这时 主线程和子线程是交替执行。

package com.hspedu.threaduse;

/**
 * 演示通过继承 Thread 类创立线程
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {

        //创立Cat对象，能够当做线程应用
        Cat cat = new Cat();

        // 读源码
        /*
            (1)
            public synchronized void start() {
                start0();
            }
            (2)
            //start0() 是本地办法，是JVM调用, 底层是c/c++实现
            //真正实现多线程的成果， 是start0(), 而不是 run
            private native void start0();

         */

        cat.start();// 启动线程-> 最终会执行cat的run办法



        //cat.run();//run办法就是一个一般的办法, 没有真正的启动一个线程，就会把run办法执行结束，才向下执行，因而要真正实现多线程，还是应该应用start办法。
        //阐明: 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行（不会等执行结束后再往下执行），这时 主线程和子线程是交替执行。
        System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字main
        for(int i = 0; i < 60; i++) {
            System.out.println("主线程 i=" + i);
            //让主线程休眠
            Thread.sleep(1000);
        }
    }
}

// 阐明
//1. 当一个类继承了 Thread 类， 该类就能够当做线程应用
//2. 咱们会重写 run办法，写上本人的业务代码
//3. run Thread 类 实现了 Runnable 接口的run办法，如下

/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */



class Cat extends Thread {

    int times = 0;
    @Override
    public void run() {//重写run办法，写上本人的业务逻辑

        while (true) {
            //该线程每隔1秒。在控制台输入 “喵喵, 我是小猫咪”
            System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
            //让该线程休眠1秒 ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times == 80) {
                break;//当times 到80, 退出while, 这时线程也就退出..
            }
        }
    }
}

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

线程利用案例2-实现Runnable 接口

  1. java是单继承的，在某些状况下一个类可能曾经继承了某个父类,这时在用继承Thread类办法来创立线程显然不可能了。
  2. java设计者们提供了另外一个形式创立线程，就是通过实现Runnable接口来创立线程

利用案例

请编写程序,该程序能够每隔1秒。在控制台输入“hi!”,当输入10次后，主动退出。请应用实现Runnable接口的形式实现。

这里底层应用了设计模式[代理模式]=>代码模仿实现Runnable接口开发线程的机制

package com.hspedu.threaduse;

/**
 * 通过实现接口Runnable 来开发线程
 */
public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start(); 这里不能调用start
        //创立了Thread对象，把 dog对象(实现Runnable),放入Thread
        Thread thread = new Thread(dog);
        thread.start();

//        Tiger tiger = new Tiger();//实现了 Runnable
          // 1.
//        ThreadProxy threadProxy = new ThreadProxy(tiger);
          // 2.
//        threadProxy.start();
    }
}

class Animal {
}

class Tiger extends Animal implements Runnable {
    // 6.
    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫....");
    }
}

//线程代理类 , 模仿了一个极简的Thread类
class ThreadProxy implements Runnable {//你能够把Proxy类当做 ThreadProxy

    private Runnable target = null;//属性，类型是 Runnable
    // 5.
    @Override
    public void run() {
        if (target != null) {
            target.run();//动静绑定（运行类型Tiger）
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }
    // 3.
    public void start() {
        start0();//这个办法时真正实现多线程办法
    }
    // 4.
    public void start0() {
        run();
    }
}


class Dog implements Runnable { //通过实现Runnable接口，开发线程

    int count = 0;

    @Override
    public void run() { //一般办法
        while (true) {
            System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());

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

            if (count == 10) {
                break;
            }
        }
    }
}

线程应用利用案例-多线程执行

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

package com.hspedu.threaduse;

/**
 * main线程启动两个子线程
 */
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();//启动第1个线程
        thread2.start();//启动第2个线程
    }
}

class T1 implements Runnable {

    int count = 0;

    @Override
    public void run() {
        while (true) {
            //每隔1秒输入 “hello,world”,输入10次
            System.out.println("hello,world " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 60) {
                break;
            }
        }
    }
}

class T2 implements Runnable {

    int count = 0;

    @Override
    public void run() {
        //每隔1秒输入 “hi”,输入5次
        while (true) {
            System.out.println("hi " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 50) {
                break;
            }
        }
    }
}

线程如何了解

继承Thread vs 实现Runnable 的区别

  1. 从java的设计来看，通过继承Thread或者实现Runnable接口来创立线程实质上没有区别,从jdk帮忙文档咱们能够看到Thread类自身就实现了
    Runnable接口。
  2. 实现Runnable接口方式更加适宜多个线程共享一个资源的状况，并且防止了单继承的限度,倡议应用Runnable。
  3. [售票零碎]，编程模仿三个售票窗口售票100,别离应用继承 Thread和实现 Runnable形式,并剖析有什么问题? 均会呈现超卖的问题。
package com.hspedu.ticket;

/**
 * 应用多线程，模仿三个窗口同时售票100张
 */
public class SellTicket {
    public static void main(String[] args) {

        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里咱们会呈现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程


        System.out.println("===应用实现接口方式来售票=====");
        SellTicket02 sellTicket02 = new SellTicket02();

        new Thread(sellTicket02).start();//第1个线程-窗口
        new Thread(sellTicket02).start();//第2个线程-窗口
        new Thread(sellTicket02).start();//第3个线程-窗口


    }
}

//应用Thread形式

class SellTicket01 extends Thread {

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

    @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() + " 售出一张票"
                    + " 残余票数=" + (--ticketNum));

        }
    }
}



//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum

    @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() + " 售出一张票"
                    + " 残余票数=" + (--ticketNum));//1 - 0 - -1  - -2

        }
    }
}

线程终止

根本阐明

  1. 当线程实现工作后，会主动退出。
  2. 还能够通过应用变量来管制run办法退出的形式进行线程，即告诉形式。

利用案例

需要:启动一个线程t，要求在main线程中去进行线程t,请编程实现。

package com.hspedu.exit_;

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

        // 如果心愿 main 线程去管制 t1 线程的终止, 必须能够批改 loop
        // 让 t1 退出 run 办法，从而终止 t1 线程 -> 告诉形式
        // 让主线程休眠 10 秒，再告诉 t1 线程退出
        System.out.println("main线程休眠10s...");
        Thread.sleep(10 * 1000);
        t1.setLoop(false);
    }
}

class T extends Thread {
    private int count = 0;
    // 设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {

            try {
                Thread.sleep(50);// 让以后线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中...." + (++count));
        }
    }
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程罕用办法

罕用办法第一组

  1. setName A //设置线程名称，使之与参数name雷同
  2. getName //返回该线程的名称
  3. startM //使该线程开始执行;Java虚拟机底层调用该线程的start0方
  4. run //调用线程对象 run办法;
  5. setPriority //更改线程的优先级
  6. getPriority //获取线程的优先级
  7. sleep //在指定的毫秒数内让以后正在执行的线程休眠(暂停执行)
  8. interrupt //中断线程

注意事项和细节

  1. start底层会创立新的线程，调用run, run 就是一个简略的办法调用，不会启动新线程。
  2. 线程优先级的范畴。
  3. interrupt，中断线程，但并没有真正的完结线程。所以个别用于中断正在休眠线程。
  4. sleep:线程的静态方法，使以后线程休眠。
package com.hspedu.method;

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相干的办法
        T t = new T();
        t.setName("timerring");
        t.setPriority(Thread.MIN_PRIORITY);//1
        t.start();//启动子线程


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

        System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1
        t.interrupt();//当执行到这里，就会中断 t线程的休眠.
    }
}

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(20000);//20秒
            } catch (InterruptedException e) {
                // 当该线程执行到一个interrupt 办法时，就会catch 一个 异样, 能够退出本人的业务代码
                // InterruptedException 是捕捉到一个中断异样.
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }
    }
}

罕用办法第二组

  1. yield：线程的礼让。让出cpu,让其余线程执行，但礼让的工夫不确定，所以也不肯定礼让胜利
  2. join：线程的插队。插队的线程一旦插队胜利，则必定先执行完插入的线程所有的工作。

案例:main线程创立一个子线程，每隔1s输入hello,输入20次,主线程每隔1秒, 输入hi，输入20次。要求:两个线程同时执行，当主线程输入5次后，就让子线程运行结束，主线程再持续。

package com.hspedu.method;

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {

        T2 t2 = new T2();
        t2.start();

        for(int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程(小弟) 吃了 " + i  + " 包子");
            if(i == 5) {
                System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
                //join, 线程插队
                //t2.join();// 这里相当于让t2 线程先执行结束
                Thread.yield();//礼让，不肯定胜利.
                System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
            }
        }
    }
}

class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程(老大) 吃了 " + i +  " 包子");
        }
    }
}

课堂练习

  1. 主线程每隔1s，输入hi,一共10次
  2. 当输入到hi5时，启动一个子线程(要求实现Runnable)，每隔1s输入hello,等该线程输入10次 hello后，退出
  3. 主线程持续输入hi，直到主线程退出.
  4. 如图,实现代码其实线程插队
package com.hspedu.method;

public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        Thread t3 = new Thread(new T3());//创立子线程
        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            if(i == 5) {//阐明主线程输入了5次 hi
                t3.start();//启动子线程 输入 hello...
                t3.join();//立刻将t3子线程，插入到main线程，让t3先执行
            }
            Thread.sleep(1000);//输入一次 hi, 让main线程也休眠1s
        }
    }
}

class T3 implements Runnable {
    private int count = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println("hello " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

用户线程和守护线程

  1. 用户线程: 也叫工作线程，当线程的工作执行完或告诉形式完结。
  2. 守护线程: 个别是为工作线程服务的，当所有的用户线程完结，守护线程主动完结。
  3. 常见的守护线程: 垃圾回收机制。

利用案例

上面咱们测试如何将一个线程设置成守护线程。

只须要将 myDaemonThread.setDaemon(true); 设置为 true 即可。

package com.hspedu.method;

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果咱们心愿当main线程完结后，子线程主动完结，只需将子线程设为守护线程即可
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();

        for( int i = 1; i <= 10; i++) {//main线程
            System.out.println("工作...");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread {
    public void run() {
        for (; ; ) {//有限循环
            try {
                Thread.sleep(1000);//休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("聊天");
        }
    }
}

线程的生命周期

线程的几种状态

JDK 中用Thread.State 枚举示意了线程的几种状态

线程状态转换图!!!!

有些书中说一共有7个状态，实际上就是将Runnable状态中Ready和Running离开了。到底是否运行还是取决于内核态的调度状况。

package com.hspedu.state_;

public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + " 状态 " + t.getState());
        t.start();

        while (Thread.State.TERMINATED != t.getState()) {
            System.out.println(t.getName() + " 状态 " + t.getState());
            Thread.sleep(500);
        }

        System.out.println(t.getName() + " 状态 " + t.getState());

    }
}

class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println("hi " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

Synchronized

线程同步机制

  1. 在多线程编程，一些敏感数据不容许被多个线程同时拜访，此时就应用同步拜访技术，保证数据在任何同一时刻，最多有一个线程拜访，以保证数据的完整性。
  2. 也能够这里了解：线程同步，即当有一个线程在对内存进行操作时，其余线程都不能够对这个内存地址进行操作，直到该线程实现操作，其余线程能力对该内存地址进行操作。

同步具体方法-Synchronized

办法一同步代码块
synchronized (对象){ // 失去对象的锁，能力操作同步代码
    // 须要被同步代码;
}
办法二办法申明

synchronized 还能够放在办法申明中，示意整个办法-为同步办法

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

剖析同步原理

互斥锁

根本介绍

  1. Java语言中，引入了对象互斥锁的概念，来保障共享数据操作的完整性。
  2. 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保障在任一时刻，只能有一个线程拜访该对象。
  3. 关键字synchronized来与对象的互斥锁分割。当某个对象用synchronized润饰时,表明该对象在任一时刻只能由一个线程拜访。
  4. 同步的局限性:导致程序的执行效率要升高。
  5. 同步办法(非动态的)的锁能够是this,也能够是其余对象(要求是同一个对象)。
  6. 同步办法(动态的)的锁为以后类自身。即类.class
package com.hspedu.syn;

/**
 * 应用多线程，模仿三个窗口同时售票100张
 */
public class SellTicket {
    public static void main(String[] args) {

        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里咱们会呈现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程


//        System.out.println("===应用实现接口方式来售票=====");
//        SellTicket02 sellTicket02 = new SellTicket02();
//
//        new Thread(sellTicket02).start();//第1个线程-窗口
//        new Thread(sellTicket02).start();//第2个线程-窗口
//        new Thread(sellTicket02).start();//第3个线程-窗口

        //测试一把
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();//第1个线程-窗口
        new Thread(sellTicket03).start();//第2个线程-窗口
        new Thread(sellTicket03).start();//第3个线程-窗口

    }
}


//实现接口方式, 应用synchronized实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    private boolean loop = true;//管制run办法变量
    Object object = new Object();


    //同步办法（动态的）的锁为以后类自身
    //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class 上
    //2. 如果在静态方法中，实现一个同步代码块.
    /*
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
     */
    public synchronized static void m1() {

    }
    public static  void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }

    //1. public synchronized void sell() {} 就是一个同步办法
    //2. 这时锁在 this对象
    //3. 也能够在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
    public /*synchronized*/ void sell() { //同步办法, 在同一时刻， 只能有一个线程来执行sell办法

        synchronized (/*this*/ object) {
            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() + " 售出一张票"
                    + " 残余票数=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }

    @Override
    public void run() {
        while (loop) {

            sell();//sell办法是一共同步办法
        }
    }
}

//应用Thread形式
// new SellTicket01().start()
// new SellTicket01().start(); 对象不是同一个，锁不住m1()

class SellTicket01 extends Thread {

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

    // 以下写法没用，因为每次对象都不是同一个，锁不住
//    public void m1() {
//        synchronized (this) {
//            System.out.println("hello");
//        }
//    }

    @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() + " 售出一张票"
                    + " 残余票数=" + (--ticketNum));

        }
    }
}


//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum

    @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() + " 售出一张票"
                    + " 残余票数=" + (--ticketNum));//1 - 0 - -1  - -2

        }
    }
}

注意事项和细节

  1. 同步办法如果没有应用static润饰:默认锁对象为this
  2. 如果办法应用static润饰，默认锁对象:以后类.class

  3. 实现的落地步骤:

    • 须要先剖析上锁的代码
    • 抉择同步代码块或同步办法（同步的范畴越小，当然效率也就越高）
    • 要求多个线程的锁对象为同一个即可!

线程的死锁

根本介绍

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁,在编程是肯定要防止死锁的产生。

利用案例

package com.hspedu.syn;

/**
 * 模仿线程死锁
 */
public class DeadLock_ {
    public static void main(String[] args) {
        //模仿死锁景象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程");
        A.start();
        B.start();
    }
}


//线程
class DeadLockDemo extends Thread {
    static Object o1 = new Object();// 保障多线程，共享一个对象,这里应用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {//结构器
        this.flag = flag;
    }

    @Override
    public void run() {

        //上面业务逻辑的剖析
        //1. 如果flag 为 T, 线程A 就会先失去/持有 o1 对象锁, 而后尝试去获取 o2 对象锁
        //2. 如果线程A 得不到 o2 对象锁，就会Blocked
        //3. 如果flag 为 F, 线程B 就会先失去/持有 o2 对象锁, 而后尝试去获取 o1 对象锁
        //4. 如果线程B 得不到 o1 对象锁，就会Blocked
        if (flag) {
            synchronized (o1) { //对象互斥锁, 上面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) { // 这里取得li对象的监督权
                    System.out.println(Thread.currentThread().getName() + " 进入2");
                }
                
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) { // 这里取得li对象的监督权
                    System.out.println(Thread.currentThread().getName() + " 进入4");
                }
            }
        }
    }
}

开释锁

上面操作会开释锁

  1. 以后线程的同步办法、同步代码块执行完结。
  2. 以后线程在同步代码块、同步办法中遇到break、return。
  3. 以后线程在同步代码块、同步办法中呈现了未解决的Error或Exception,导致异样完结。
  4. 以后线程在同步代码块、同步办法中执行了线程对象的wait()办法，以后线程暂停，并开释锁。

上面操作不会开释锁

  1. 线程执行同步代码块或同步办法时，程序调用Thread.sleep()、Thread.yield()办法暂停以后线程的执行,不会开释锁
  2. 线程执行同步代码块时，其余线程调用了该线程的suspend()办法将该线程挂起，该线程不会开释锁。提醒:应尽量避免应用suspend()和resume()来控制线程，办法不再举荐应用

作业

  1. 编程题

    (1)在main办法中启动两个线程

    (2)第1个线程循环随机打印100以内的整数

    (3)直到第2个线程从键盘读取了“Q”命令。

    package com.hspedu.homework;

import java.util.Scanner;


public class Homework01 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);//肯定要留神.
        a.start();
        b.start();
    }
}

//创立A线程类
class A extends Thread {
    private boolean loop = true;

    @Override
    public void run() {
        //输入1-100数字
        while (loop) {
            System.out.println((int)(Math.random() * 100 + 1));
            //休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("a线程退出...");

    }

    public void setLoop(boolean loop) {//能够批改loop变量
        this.loop = loop;
    }
}

//直到第2个线程从键盘读取了“Q”命令
class B extends Thread {
    private A a;
    private Scanner scanner = new Scanner(System.in);

    public B(A a) {//结构器中，间接传入A类对象
        this.a = a;
    }

    @Override
    public void run() {
        while (true) {
            //接管到用户的输出
            System.out.println("请输出你指令(Q)示意退出:");
            char key = scanner.next().toUpperCase().charAt(0);
            if(key == 'Q') {
                //以告诉的形式完结a线程
                a.setLoop(false);
                System.out.println("b线程退出.");
                break;
            }
        }
    }
}

  2. 编程题

    (1)有2个用户别离从同一个卡上取钱(总额:10000)

    (2)每次都取1000,当余额有余时,就不能取款了

    (3)不能呈现超取景象=》线程同步问题.

    package com.hspedu.homework;

public class Homework02 {
    public static void main(String[] args) {
        T t = new T();
        Thread thread1 = new Thread(t);
        thread1.setName("t1");
        Thread thread2 = new Thread(t);
        thread2.setName("t2");
        thread1.start();
        thread2.start();
    }
}

//1.因为这里波及到多个线程共享资源，所以咱们应用实现Runnable形式
//2. 每次取出 1000
class T implements  Runnable {
    private int money = 10000;

    @Override
    public void run() {
        while (true) {

            //解读
            //1. 这里应用 synchronized 实现了线程同步
            //2. 当多个线程执行到这里时，就会去抢夺 this对象锁
            //3. 哪个线程抢夺到(获取)this对象锁，就执行 synchronized 代码块, 执行完后，会开释this对象锁
            //4. 抢夺不到this对象锁，就blocked ，筹备持续抢夺
            //5. this对象锁是非偏心锁.

            synchronized (this) {//
                //判断余额是否够
                if (money < 1000) {
                    System.out.println("余额有余");
                    break;
                }

                money -= 1000;
                System.out.println(Thread.currentThread().getName() + " 取出了1000 以后余额=" + money);
            }

            //休眠1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章