黑马程序员——多线程

于 2015-06-15 10:11:17 发布
阅读量264 收藏
点赞数
分类专栏： 黑马程序员——多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a982541919/article/details/46500709
版权

——- android培训、java培训、期待与您交流！ ———-

线程和进程是什么？：

进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。
该顺序是一个执行路径，或者叫一个控制单元。

线程：就是进程中的一个独立的控制单元。
线程在控制着进程的执行。

一个进程中至少有一个线程。
java虚拟机启动的时候会有一个进程java.exe。

该进程中至少有一个线程负责java程序执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为 主线程。

创建线程的第一种方式：继承Thread类

步骤：
1，定义类继承Thread。
2，复写Thread类中的run方法。
目的：将自定义代码存储在run方法。让线程运行。
3，调用线程的start方法。
该方法有两个作用：启动线程、调用run方法

代码示例：

class ThreadDemo extends Thread {//1,继承Thread类
    public void run() {//2，复写run方法
        for (int i = 0; i < 60; i++) {
            System.out.println("Thread----" + i);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();// 创建好一个线程
        td.start(); // 3，开启线程并执行该线程的run方法
        // td.run //仅仅是普通的对象调用方法。线程虽然创建了，但是并没有运行
        for (int i = 0; i < 60; i++)
            System.out.println("hello------" + i);

    }
}

运行此程序发现：运行结果每一次都不同。

因为多个线程都获取cpu的执行权。cpu执行到谁，谁就运行。
明确一点，在某一个时刻，只能有一个程序在运行。（多核除外）
cpu在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象把，多线程的运行行为理解为互相抢夺cpu的执行权。

这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长时间，cpu说的算

td.start(); 和 td.run();的区别：
td.start();开启线程并执行该线程的run方法，相当于程序中有两个线程
一个线程执行main中的方法，一个线程执行run中的方法

td.run();就是普通的对象调用，并没有启动线程，相当于程序中只有一个
主线程在执行，当执行到td.dun()时，就调用该对象的方法，执行完后再回到
main方法中继续执行

注意：如果主函数创建两个线程在执行，那么栈中会创建两个run方法。
两个run方法中的内容都是独立的。
如：两个run方法中都有变量 num ，那么num在两个run方法中互不干扰。

/*
 * 练习：
 * 创建两个线程，和主线程交替运行。
 * 
 * 线程都有自己默认的名称。
 * 名称格式为Thread-编号， 该编号从0开始
 * 
 * Thread.currentThread(); 获取当前线程对象。
 * getName();   获取线程名称
 * 
 * 设置线程名称：setName或者调用线程的构造函数

 */
class ThreadDemo extends Thread{
    private String name;
    public ThreadDemo(String name){
        super(name);//调用Thread的构造函数，设置线程名称
    }
    public void run(){
        for(int i=0;i<60;i++){
            //this.getName获取线程名称，默认名称格式为 Thread-编号
            //this.getName可以改成Thread.currentThread().getName，因为Thread.currentThread()
            //可以获取线程的对象
            System.out.println(this.getName() + "..." + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        ThreadDemo td1 = new ThreadDemo("td1...哈哈");
        ThreadDemo td2 = new ThreadDemo("td2...呵呵");
        td1.start();
        td2.start();
        //td1.run();    //这种方式并不是创建两个线程并执行，只相当于方法调用
        //td2.run();    //这种方式并不是创建两个线程并执行，只相当于方法调用
        for(int i = 0;i<60;i++)
            System.out.println("main....嘿嘿");
    }
}

创建线程的第二种方式：实现Runnable接口

步骤：
1.定义类实现Runnable接口
2.覆盖Runnable接口中的run方法，将要运行的代码存放在run方法中
3.通过Thread类建立线程对象
4.将Runnable接口的子类对象，作为实际参数传递给Thread类的构造函数。
5.调用Thread类的start方法开启线程，使得start方法自动调用Runnable子类的的run方法。

实现方式(implements Runnable)和继承方式(extends Thread)有什么区别呢？（面试题）

继承Thread：线程代码存放在Thread的子类的run方法中。但是具备单继承的局限性
实现Runnable：线程代码存放在实现Runnable接口的子类的run方法中。避免了单集成的局限性

代码示例：

/*
 需求：简单的卖票程序。
 多个窗口同时卖票（假设为4个卖票窗口）
 */

class Ticket implements Runnable { // 创建一个 票 类，实现了Runnable的run方法。注意：不是继承Thread
    private int i = 100;

    public void run() {//将要运行的代码存放在run方法中
        while (true) {
            if (i > 0)
                System.out.println(Thread.currentThread().getName() + "..."
                        + i--);
            else
                return;
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        Ticket t = new Ticket();

        // 通过Thread类建立线程对象，并将Runnable接口的子类对象，
        //作为实际参数传递给Thread类的构造函数
        Thread th1 = new Thread(t);
        Thread th2 = new Thread(t); 
        Thread th3 = new Thread(t);
        Thread th4 = new Thread(t);

        th1.start();//调用Thread类的start方法开启线程
        th2.start();
        th3.start();
        th4.start();
    }
}

同步代码块：synchronized

synchronized(对象)
{
    需要被同步的代码块
}

同步代码快中的 对象 如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。（如同火车上的卫生间，当有人进去锁门后，外边的人只能等待）

同步的前提：(注意：如果加锁过后程序还是不安全，应该考虑程序中的锁是否符合这两个前提)
1，必须要有两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，比较消耗资源。

代码示例：

/*
通过运行结果：发现出现了0，-1，-2等错票

多线程的运行出现了安全问题

问题的原因：
    当多条语句在操作同一个线程的共享数据时，一个线程对多条语句只执行了一部分，
    还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

解决办法：
    对多条操作共享数据的语句，只能让一个线程执行完。在执行过程中，
    其他线程不可以参与执行。

java对于多线程的安全问题提供了专业的解决方式。

就是同步代码块：
*/
class Ticket implements Runnable { // 创建一个 票 类，实现了Runnable的run方法
    private int i = 100;

    public void run() {
        while (true) {
            if (i > 0) {
                try {
                    Thread.sleep(10);// 使线程执行10后，等待10毫秒再继续执行
                } catch (InterruptedException e) {
                }
                System.out.println(Thread.currentThread().getName() + "..."+ i--);
            } else {
                return;
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        Thread th1 = new Thread(t);// 创建了一个线程，相当于一个售票窗口
        Thread th2 = new Thread(t);// 创建了一个线程，相当于一个售票窗口
        Thread th3 = new Thread(t);// 创建了一个线程，相当于一个售票窗口
        Thread th4 = new Thread(t);// 创建了一个线程，相当于一个售票窗口
        th1.start();
        th2.start();
        th3.start();
        th4.start();
    }
}

由于出现了错票，将以上代码修改为以下代码

class Ticket implements Runnable { // 创建一个 票 类，实现了Runnable的run方法
    private int i = 100;
    Object obj = new Object();
    public void run() {
        while (true) {
            synchronized (obj) {//加上这句语句后，if代码没有执行完，其他的线程不许进入if语句
                if (i > 0) {
                    try {
                        Thread.sleep(10);// 使线程执行10后，等待10毫秒再继续执行
                    } catch (InterruptedException e) {
                    }
                    System.out.println(Thread.currentThread().getName() + "..."
                            + i--);
                } else {
                    return;
                }
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        Thread th1 = new Thread(t);// 创建了一个线程，相当于一个售票窗口
        Thread th2 = new Thread(t);// 创建了一个线程，相当于一个售票窗口
        Thread th3 = new Thread(t);// 创建了一个线程，相当于一个售票窗口
        Thread th4 = new Thread(t);// 创建了一个线程，相当于一个售票窗口
        th1.start();
        th2.start();
        th3.start();
        th4.start();
    }
}
/* 
    需求：
    银行有一个金库。
    有两个用户分别存300元，每次存100元，存3次。

    目的：该线程是否有安全问题，如果有，如何解决

如何找到问题：
1，明确哪些代码是多线程运行代码。
    在本题中，多线程运行的代码是run方法和add方法
2，明确哪些是共享数据
    在本题中，对象j是共享数据，成员函数num也是共享数据。
3，明确多线程运行代码中，哪些语句是操作共享数据的
    在本题中，j.add是操作共享数据的，但是j.add只有一句话，不能被多线程给分开读。
    而num有两句话(num+=x，System.out.println(num))，是可以被多线程分开读的，
    如：第一个线程读到num+=x时，第二个线程插进来读取nun+=x，而导致第一个线程没有读到System.out.println(num)。
    所以，本题中要分析的就是num+=x，System.out.println(num)。


 */
class JinKu {   //金库类
    private int num = 0;
    Object obj = new Object();
    public void add(int x) {
        num += x;
//      try {Thread.sleep(10);} catch (InterruptedException e) {}//此处代码可以不用try，可以把异常抛出去。但是这样做在run方法中，必须处理异常
        System.out.println(num);
    }
//  该线程有问题，如果在该线程add方法中的num+=x下边，
//  加入try {Thread.sleep(10);} catch (InterruptedException e) {}
//  那么就会出现错误，应该将add()方法改为如下
//  public void add(int x){
//      synchronized (obj) {
//          num+=x;
//          try {Thread.sleep(10);} catch (InterruptedException e) {}
//          System.out.println(num);
//      }
//  }

}
class YongHu implements Runnable {  //用户类
    JinKu j = new JinKu();
    public void run() {
        for (int i = 0; i < 3; i++)
            j.add(100);
    }
}
public class Demo {
    public static void main(String[] args) {
        YongHu yh = new YongHu();
        Thread th1 = new Thread(yh);
        Thread th2 = new Thread(yh);
        th1.start();
        th2.start();
    }
}

同步函数和静态同步函数：

同步函数：public synchronized void show(){}
静态同步函数：public static synchronized void show(){}

同步函数用的是哪一个锁呢？
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数用的锁是this。
（记住结论就行：同步函数用的锁是this）

如果同步函数被静态修饰后，使用的锁是什么呢？
通过验证，发现不再是this，因为静态方法中也不可以定义this。
静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码对象。
类名.class 该对象的类型是class

静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class
（记住结论就行：静态同步函数用的锁是 类名.class）

代码示例：

/*
 卖票的例子，使用同步函数来加锁
 */
class Test implements Runnable {
    int count = 100;

    public void run() {
        while (true) {
            maiPiao();
        }
    }

    public synchronized void maiPiao() {//在函数上加同步
        if (count > 0) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + "..."
                    + count--);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        Test t = new Test();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}

死锁：

死锁就是，在我这个锁中用你那个锁，在你那个锁中又要用到我这个锁。

形象的比喻就是：两根筷子。A一根B一根，每人只拿一根筷子就无法吃饭。
除非B把筷子给A，或者A把筷子给B，这样才能吃饭。如果A不给B，B也不给A，
那么就无法吃饭，导致死锁

/*
    死锁程序（面试喜欢考）
 */
class Test1 implements Runnable {
    public void run() {
        while (true) {
            //使用Test1.class锁
            synchronized (Test1.class) {
                System.out.println("Test1...Test1.class");
                //使用Test2.class锁
                synchronized (Test2.class) {
                    System.out.println("Test1...Test2.class");
                }
            }
        }
    }
}

class Test2 implements Runnable {
    public void run() {
        while (true) {
            //使用Test2.class锁
            synchronized (Test2.class) {
                System.out.println("Test2...Test2.class");
                //使用Test1.class锁
                synchronized (Test1.class) {
                    System.out.println("Test2...Test1.class");
                }
            }
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        new Thread(new Test1()).start();
        new Thread(new Test2()).start();
        /*
        本示例中，发生死锁的原因：

            当Test1类中的程序输出"Test1...Test1.class"时，
            cpu突然切换到Test2类中的线程。
            于是就输出了"Test2...Test2.class"。

            这时，Test2类中的程序继续执行，读到了Test1.class锁，
            由于Test1.class锁在Test1类中没有释放，
            于是程序就在Test2类中等待Test1.class锁释放。

            这时，cpu切换到了Test1类中的程序，
            由于Test2.calss锁又在Test2类中序没有释放，
            于是Test1类中的程序在等待Test2.class释放。

            最终导致了，Test1类在等待Test2类释放锁，Test2类在等待Test1类释放锁，
            从而导致了死锁

        */
    }
}

多线程中的懒汉式

代码示例：

class Single{
    private static Single s = null;
    private Single(){}
    public static Single getSingle(){
        if (s == null) {//双重if判断语句
            synchronized (Single.class) {
                if (s == null) {
                    s = new Single();
                }
            }
        }
        return s;
    }
}

线程间的通讯：

线程间的通讯：可以理解为，一个线程在存数据，另一个线程在取数据。

如：
拉煤的例子：一个车在送煤，另外一个车在取煤。
生产者例子：生产者不断的生产物品，而消费者不断的消费物品

代码示例：

class Person {// 定义一个人类
    String name;
    String sex;// 性别
}

class Input implements Runnable {
    Person p;
    int x = 0;// 用来控制if和else语句，x为0时执行if，x为1时执行else

    public Input(Person p) {// 为了保证和Output类中的Person是同一个对象，将参数定义为Person，
                            // 这样就能确保传递进来的参数和Outpue类一样
        this.p = p;
    }

    public void run() {//此run方法不断的初始化姓名和性别。
        while (true) {
            synchronized (p) {// 此处的锁用p是因为，本类中的p和Output中的p是同一个对象，如果
                                // 此处不加同步输出结果不是我们想要的//
                                //可能会输出  “张三，nv”，“lili，男”等错误
                    if (x == 0) {
                        p.name = "张三";
                        p.sex = "男";
                    } else {
                        p.name = "lili";
                        p.sex = "nv";
                    }
                x = (x + 1) % 2;
            }
        }
    }
}

class Output implements Runnable {
    Person p;

    public Output(Person p) {// 为了保证和Input类中的Person是同一个对象，将参数定义为Person，
                                // 这样就能确保传递进来的参数和Input类一样
        this.p = p;
    }

    public void run() {//此run方法不断的获取姓名和性别
        while (true) {
            synchronized (p) {// 此处的锁用p是因为，本类中的p和Input中的p是同一个对象
                                // 此处不加同步输出结果会报错
                System.out.println(p.name + "...." + p.sex);
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        Person p = new Person();

        Input in = new Input(p);
        Output out = new Output(p);

        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);

        t1.start();
        t2.start();
    }
}

发现，每次输出时候并不是存放一个数据输出一次，而是一下子输出一大片，
于是，将代码修改为下面的代码，让程序每存放一个数据，就输出一个数据。
使用等待唤醒机制。既：wait() 和 notify()
注意：wait()、notify()方法必须使用在同步代码块或者同步方法中

class Person {// 定义一个人类
    String name;
    String sex;// 性别
    boolean flag = false;   //标记是否已经存放了name和sex
}

class Input implements Runnable {
    Person p;
    int x = 0;// 用来控制if和else语句，x为0时执行if，x为1时执行else

    public Input(Person p) {// 为了保证和Output类中的Person是同一个对象，将参数定义为Person，
                            // 这样就能确保传递进来的参数和Outpue类一样
        this.p = p;
    }

    public void run() {
        while (true) {
            synchronized (p) {// 此处的锁用p是因为，本类中的p和Output中的p是同一个对象，如果
                                // 此处不加同步输出结果会报错
                if(p.flag)//如果存放了name和sex，那么就进入等待，当进入等待后，后边的语句都不执行
                    try {p.wait();} catch (InterruptedException e) {}//使用wait()时，必须标识对象（锁）
                if (x == 0) {
                    p.name = "张三";
                    p.sex = "男";
                } else {
                    p.name = "lili";
                    p.sex = "nv";
                }
                p.flag = true;  //存放name和sex后，让标记为true
                p.notify(); //在进入等待之前先唤醒Output中的wait()，使用notify()时，必须标识对象（锁）
                x = (x + 1) % 2;
            }
        }
    }
}

class Output implements Runnable {
    Person p;

    public Output(Person p) {// 为了保证和Input类中的Person是同一个对象，将参数定义为Person，
                                // 这样就能确保传递进来的参数和Input类一样
        this.p = p;
    }

    public void run() {
        while (true) {
            synchronized (p) {// 此处的锁用p是因为，本类中的p和Input中的p是同一个对象
                                // 此处不加同步输出结果会报错
                if(!p.flag) //如果已经输出了name和sex，那么就进入等待，进入等待后，后边的语句都不执行
                    try {p.wait();} catch (InterruptedException e) {}//使用wait()时，必须标识对象（锁）
                System.out.println(p.name + "...." + p.sex);
                p.flag = false; //输出name和sex后，让标记为false
                p.notify(); 在进入等待之前先唤醒Input中的wait()，使用notify()时，必须标识对象（锁）
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        Person p = new Person();

        Input in = new Input(p);
        Output out = new Output(p);

        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);

        t1.start();
        t2.start();
    }
}
/* 
 * 练习：生产者和消费者
 * 要求：定义4个线程，生产者有两个，消费者有两个，当生产一个，必须被消费一个
 * 
 * 
 * 对于多个生产者和消费者。
 * 为什么要定义while判断标记。
 * 原因：让唤醒线程再判断一次标记
 * 
 * 为什么定义notifyAll。
 * 因为需要唤醒对方线程。
 * 因为只用notify容易出现只唤醒本方线程的情况。导致程序中所有线程都等待
 *
 * 但是呢notifyAll不仅唤醒了对方，而且还唤醒了本方
 */
class Test{
    int i = 0;
    boolean flag = false;
    // t1   t2
    public synchronized void shengChan(String name){
        while(flag)//必须用while循环，否则运行结果不是想要的
            try {wait();} catch (InterruptedException e) {}  // 【t1(放弃执行资格)   t2(放弃执行资格，同时唤醒t1)  t1(由于循环判断，放弃执行资格)】

        System.out.println(Thread.currentThread().getName()+"..."+name+"..."+i);
        flag = true;
        notifyAll();//必须全部唤醒，否则会出现所有线程都等待
    }

    // t3  t4
    public synchronized void xiaoFei(String name){
        while(!flag)//必须用while循环，否则运行结果不是想要的
            try {wait();} catch (InterruptedException e) {}// 【t3(放弃执行资格，同时唤醒t1,t2)  t4（放弃执行资格，同时唤醒t3） t3(由于循环判断，放弃执行资格)】
        System.out.println(Thread.currentThread().getName()+"..."+name+"......."+i++);
        flag = false;
        notifyAll();//必须全部唤醒，否则会出现所有线程都等待
    }
}
class ShengChan implements Runnable{
    Test t;
    public ShengChan(Test t){
        this.t = t;
    }
    public void run(){//此run方法不断的生产数据
        while(true){
            t.shengChan("生产者");
        }
    }
}
class XiaoFei implements Runnable{
    Test t;
    public XiaoFei(Test t){
        this.t = t;
    }
    public void run(){//此run方法不断的获取数据
        while(true){
            t.xiaoFei("消费者");
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        Test t = new Test();

        ShengChan sc = new ShengChan(t);
        XiaoFei xf = new XiaoFei(t);

        Thread t1 = new Thread(sc);
        Thread t2 = new Thread(sc);
        Thread t3 = new Thread(xf);
        Thread t4 = new Thread(xf);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

JDK 1.5中提供了多线程升级解决方案。Lock

将同步synchronized替换成了Lock操作。
将Object中的wait,notify,notifyAll，替换成了Condition对象。
该对象可以Lock锁进行获取。

该示例中，实现了本方只唤醒对方操作。而上个示例的notifyAll不仅唤醒了对方，还唤醒了本方

代码示例：

import java.util.concurrent.locks.*;
class Test {
    int i = 0;
    boolean flag = false;
    private Lock lock = new ReentrantLock();// 创建一个锁，替代了synchronized
    private Condition condition_shengchan = lock.newCondition(); // 创建一个条件，替代了wait(),notify,notifyAll
    private Condition condition_xiaofei = lock.newCondition(); // 创建一个条件，替代了wait(),notify,notifyAll

    public void shengChan(String name) throws InterruptedException {//生产者
        lock.lock();// 相当于synchronized，只不过是替换了synchronized
        try {
            while (flag)// 必须用while循环，否则运行结果不是想要的   

                condition_shengchan.await();// 使生产者进入等待状态。使用该方法会抛出异常，所以在方法上声明异常，
                                            //该方法使生产这个锁进入等待
            System.out.println(Thread.currentThread().getName() + "..." + name
                    + "..." + i);
            flag = true;
            condition_xiaofei.signal();//在生产者进入等待之前，先唤醒消费，使得消费者开始执行
        } finally {
            lock.unlock();// 锁必须要被释放，必须要执行，所以放在finally中，就算出现异常，此处依旧执行
        }
    }

    public void xiaoFei(String name) throws InterruptedException {//消费者
        lock.lock();// 相当于synchronized，只不过是替换了synchronized
        try {
            while (!flag)// 必须用while循环，否则运行结果不是想要的

                condition_xiaofei.await();// 使消费者进入等待状态。使用该方法会抛出异常，所以在方法上声明异常。
                                            ////该方法使消费这个锁进入等待
            System.out.println(Thread.currentThread().getName() + "..." + name
                    + "......." + i++);
            flag = false;
            condition_shengchan.signal();//在消费者进入等待之前，先唤醒生产者，使得生产者开始执行
        } finally {
            lock.unlock();//锁必须要被释放，必须要执行，所以放在finally中，就算出现异常，此处依旧执行
        }
    }
}

class ShengChan implements Runnable {
    Test t;

    public ShengChan(Test t) {
        this.t = t;
    }

    public void run() {
        while (true) {
            try {
                t.shengChan("生产者");//由于该方法抛出异常，所以这里需要捕获异常
            } catch (InterruptedException e) {
            }
        }
    }
}

class XiaoFei implements Runnable {
    Test t;

    public XiaoFei(Test t) {
        this.t = t;
    }

    public void run() {
        while (true) {
            try {
                t.xiaoFei("消费者");//由于该方法抛出异常，所以这里需要捕获异常
            } catch (InterruptedException e) {
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        Test t = new Test();

        ShengChan sc = new ShengChan(t);
        XiaoFei xf = new XiaoFei(t);

        Thread t1 = new Thread(sc);
        Thread t2 = new Thread(sc);
        Thread t3 = new Thread(xf);
        Thread t4 = new Thread(xf);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

interrupt

stop方法已经过时，那么如何停止线程？

只有一种方式，就是让run方法结束。
开启多线程运行，运行代码通常是循环结构。

只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊情况：
当线程处于冻结状态。
就不会读取到标记。那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。
强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

Thread类提供该方法 interrupt();

import java.util.Scanner;
class Test implements Runnable{
    boolean flag = true;
    public synchronized void run(){
        while(flag){
            try {
                wait();//使用interrupt()方法，强制让线程抛出异常。在异常中将循环标记置为false，当重新回到循环判断时，由于flag为false,循环就结束了
            } catch (InterruptedException e) {
                flag = false;
            }
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        Thread t = new Thread(new Test());
        t.start();
        Scanner input = new Scanner(System.in);
        input.nextLine();//输入一个字符串
        t.interrupt();//当输入一个字符串后，直接中断t线程
    }
}

setDaemon(boolean)

将线程标记为守护线程 setDaemon(boolean);

守护线程必须在线程开启前使用。既：在t.start()方法前使用
守护线程代表的是，当主线程结束时，守护线程也结束。它随着主线程存在而存在，随着主线程消失而消失

class Test implements Runnable{

    public void run(){
        while(true){
            System.out.println(Thread.currentThread().getName());
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Test());
        Thread t2 = new Thread(new Test());

        //标记为守护线程。在t.start()方法前使用
        t1.setDaemon(true);//true代表开启守护线程。
        t2.setDaemon(true);

        t1.start();
        t2.start();
        for(int i=0;i<50;i++){
            System.out.println("main...");
        }
    }
}

join

join:
当A线程执行到了 B线程的.join方法时 ，A就会等待。等B线程执行完，A才会执行。
join可以用来临时加入线程执行

class ThreadDemo implements Runnable{
    public void run(){
        for(int i=0;i<30;i++){
            System.out.println(Thread.currentThread().getName()+"..."+i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        ThreadDemo st = new ThreadDemo();
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        t1.start(); 
        try {
            t1.join();//当主线程执行到此处时候，先等待t1线程执行完毕，主线程才继续往下执行
        } catch (InterruptedException e) {
        }
        t2.start();
        for(int i=0;i<30;i++){
            System.out.println("main........."+i);
        }
        System.out.println("over");
    }
}

setPriority

设置线程的优先级 setPriority(int num);
输出线程的主要信息 toString();

class ThreadDemo implements Runnable{
    public void run(){
        for(int i=0;i<30;i++){
            System.out.println(Thread.currentThread().toString());
            /*
             结果：
                Thread[Thread-0,10,main]
                Thread[Thread-1,5,main]

                Thread-0 或者Thread-1代表线程的编号。
                main代表该线程是被哪个线程开启的。很明显，此线程是被主线程开启的
                5代表优先级。优先级越高，获取到cpu执行权的概率越高。优先级最高为10
             */
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        ThreadDemo st = new ThreadDemo();
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        t1.start();//主线程开启了一个线程

        t1.setPriority(10);//设置t1线程的优先级为10。那么t1线程抢到cpu执行权的概率就比较高

        t2.start();//主线程开启了一个线程
    }
}

Thread.yield()

释放执行权Thread.yield();
当线程执行到Thread.yield()时，线程会放弃执行权(既：cpu切换到该线程时，该线程不执行)，然后再重新获取执行权。

例如：
当线程A放弃执行权后，线程B就更容易抢到cpu的执行权。
这样使得程序比较协调，使得每个线程被执行到的概率大些。既：A执行一次，B执行一次，A执行一次…..

class ThreadDemo implements Runnable{
    public void run(){
        for(int i=0;i<70;i++){
            System.out.println(Thread.currentThread().toString());
            Thread.yield();
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        ThreadDemo st = new ThreadDemo();
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        t1.start();
        t2.start();
    }
}
a982541919
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员入学Java知识——精华总结.doc
05-09
Java内置了对多线程的支持，通过Thread类或实现Runnable接口可以创建并管理多个执行线程。 17. **网络编程**： Java提供了丰富的API进行网络通信，如Socket和ServerSocket类，用于客户端和服务器之间的连接。 ...
黑马程序员 安卓学院 万元哥项目经理 分享220个代码实例
10-07
|--利用FinalHttp实现多线程断点续传 |--加密之MD5 |--动画Animation详解 |--动画之view左右抖动 |--动画之移动动画 |--动画之组合动画 |--动画之缩放动画ScaleAnimation |--反序列化对象 |--发送短信 读天气 调音量...
黑马程序员入学Java知识——精华总结
03-07
8. **多线程**：Java内置对多线程的支持，通过`Thread`类和`Runnable`接口可以创建并管理线程。理解线程同步和互斥的概念，如`synchronized`关键字和`wait()`, `notify()`方法，有助于编写高效的并发程序。 9. **...
黑马程序员 hibernate 2016版讲义和笔记(4天全)
10-07
《Hibernate技术深度剖析——基于黑马程序员2016版讲义与笔记》 Hibernate，作为Java领域中的一个著名持久化框架，为开发者提供了强大的对象关系映射（ORM）功能，极大地简化了数据库操作。本资料集是黑马程序员...
黑马程序员_(适合初学者入门的Java基础视频)
08-24
8. **多线程**：介绍线程的概念，讲解如何创建和控制线程，以及同步机制，如synchronized关键字和wait/notify机制。 9. **Java API和类库**：通过实例演示如何使用Java标准库中的各种类，如Date、Calendar、Math等...
weixin105文章管理系统+ssm.zip
08-23
随着计算机技术的成熟，互联网的建立，如今，PC平台上有许多关于文章管理方面的应用程序，但由于使用时间和地点上的限制，用户在使用上存在着种种不方便，而开发一款基于微信小程序的文章管理系统，能够有效地解决这个问题。 本基于微信小程序的文章管理系统是针对文章管理而开发，采用微信开发者工具进行微信端开发，使用MYSQL数据库进行系统数据的储存，系统满足用户通过微信客户端进行文章管理的需求。本小程序是以微信为入口的，可以说是在自带接近10亿的流量人口。整个系统不仅操作简单、便捷，而且节约用户的时间及资源成本等，仅需通过一部手机和微信号即可满足用户们的需求。
AIoT星图研究院2024中国物联网产业创新白皮书
08-23
物联网产业概述：介绍了物联网的概念、产业结构，以及中国物联网产业的发展现状，包括市场规模、市场结构、用户规模、终端连接数和投融资情况。 物联网产业面临的问题与机遇：分析了产业面临的新挑战，如安全性、标准与互操作性、可扩展性、设备功耗、可靠性和延迟等，并探讨了产业迎来的新机遇。 政策、法律法规及标准：梳理了全国性政策，包括感知层、通信层、平台层和应用层的相关政策，并讨论了物联网数据安全与数据合规问题。 感知层技术：深入分析了RFID无源物联网、毫米波雷达、激光雷达、柔性传感器、智能传感器、3D视觉传感器、MEMS传感器等技术，并探讨了北斗及卫星高精度定位技术。 传输层技术：涵盖了5G、LTE Cat.1、6G、卫星通信、星闪、蓝牙、Wi-Fi、ZigBee、NFC、LiFi、LoRa等通信技术。 平台与软件层：讨论了物联网平台产业、物联网操作系统、物联网数据库和物联网大模型产业的分析。 应用层：分析了产业物联网和消费物联网的应用领域，包括智慧城市、智能工业、车联网、智慧医疗、智慧园区、智慧农业、智慧零售、智慧能源、智慧物流等。 市场运营分析：物联网市场规模、结构、用户规模
weixin120校友林微信小程序+ssm.zip
08-23
本校友林微信小程序管理员可以管理员可以修改密码。可以对注册用户进行管理。对树木进行管理，所属科管理，树木领取管理数，跟踪状态，管理用户信息。统计管理，树木捐款管理、留言板管理，而微信小程序则可以对管理员管理的功能在微信小程序上进行操作，因而具有一定的实用性。本站后台采用Java的SSM框架进行后台管理开发，可以在浏览器上登录进行后台数据方面的管理，MySQL作为本地数据库，微信小程序用到了微信开发者工具，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校友林微信小程序管理工作系统化、规范化。 本系统的使用使管理人员从繁重的工作中解脱出来，实现无纸化办公，能够有效的提高校友林微信小程序管理效率。
基于微信小程序警务辅助人员管理系统设计与实现.docx
08-23
基于微信小程序警务辅助人员管理系统设计与实现.docx
javaWeb传智播客网上书城项目源码(设计以及实现论文).zip
08-23
该毕业设计将深入探讨如何通过Java语言构建一个完整且高效的《javaWeb传智播客网上书城项目源码(设计以及实现论文)》。毕业设计的架构涵盖了从基础框架搭建到关键功能实现的每一个环节，并采用了模块化设计，使整个系统易于理解、扩展和维护。 无论是数据处理、用户交互还是后台管理，我们都为您提供了详细的代码示例和设计文档。 这个毕业设计的独特之处在于其高度的实用性和灵活性。 我们提供了全面的资源包，帮助您快速入门，并支持您在此基础上进行个性化的功能扩展。 无论您是正在寻找灵感的学生，还是需要现成解决方案的开发者，下载该资源将助您事半功倍。
weixin042居住证申报系统+ssm.zip
08-23
随着我国经济迅速发展，人们对手机的需求越来越大，各种手机软件也都在被广泛应用，但是对于手机进行数据信息管理，对于手机的各种软件也是备受用户的喜爱，居住证申报系统被用户普遍使用，为方便用户能够可以随时进行居住证申报系统的数据信息管理，特开发了基于居住证申报系统的管理系统。 居住证申报系统的设计主要是对系统所要实现的功能进行详细考虑，确定所要实现的功能后进行界面的设计，在这中间还要考虑如何可以更好的将功能及页面进行很好的结合，方便用户可以很容易明了的找到自己所需要的信息，还有系统平台后期的可操作性，通过对信息内容的详细了解进行技术的开发。 居住证申报系统的开发利用现有的成熟技术参考，以源代码为模板，分析功能调整与居住证申报系统管理的实际需求相结合，讨论了基于居住证申报系统管理的使用。
基于ssm和vue的 教资考前指导系统源码 （优秀毕业设计源码）
08-23
1. 教资考前指导系统代码说明：经导师指导并认可通过的98分毕设项目代码。 2.适用对象：本代码学习资料适用于计算机、电子信息工程、数学等专业正在做毕设的学生，需要项目实战练习的学习者，也适用于课程设计、期末大作业。 3.技术栈：前端是vue，后端是ssm，项目代码都经过严格调试，代码没有任何bug！ 4. 作者介绍：大厂码农，java领域创作者，阿里云开发社区乘风者计划专家博主，专注于大学生项目实战开发，文章底部有博主联系方式，更多优质系统、项目定制请私信。 5. 最新计算机软件毕业设计选题大全: https://blog.csdn.net/weixin_45630258/article/details/135901374
秒针系统2024中国消费者兴趣圈层Q1白皮书.pdf
08-23
【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书.pdf【秒针系统】2024中国消费者兴趣圈层Q1白皮书
方案-XX钢铁信息化方案设计.pdf
08-23
方案-XX钢铁信息化方案设计.pdf
S19-程序分析大作业：使用 SOOT 框架，实现 Java 上的静态指针分析.zip
08-23
S19-程序分析大作业：使用 SOOT 框架，实现 Java 上的静态指针分析
多用户协同：软件冲突的艺术化解决
08-23
编程故障处理，也常被称为调试（Debugging），是软件开发过程中识别、分析和修复程序中错误或故障的过程。它是确保软件质量和可靠性的关键环节。以下是编程故障处理的详细解释： ###故障发生的原因 - **语法错误**：编程语言的规则没有正确遵守。 - **逻辑错误**：程序实现了错误的逻辑或算法。 - **运行时错误**：程序在运行时遇到了未预见的情况，如除以零、数组越界等。 - **资源问题**：内存不足、磁盘空间不足等。 - **外部依赖故障**：依赖的外部系统或服务不可用。 ### 故障处理的步骤 - **识别问题**：通过用户反馈、测试结果或监控报警发现问题。 - **复现问题**：在可控环境中稳定复现问题，为进一步分析做准备。 - **信息收集**：收集相关的日志、错误信息、堆栈跟踪等数据。 - **分析问题**：根据收集到的信息，分析问题的可能原因。 - **定位问题**：确定问题发生的具体位置，如代码行、模块或系统组件。 - **制定修复方案**：根据问题原因，设计解决方案或修复措施。 - **实施修复**：在开发环境中实施修复，并进行单元测试。 - **测试验证
2018_2019_校招_春招_秋招_算法_机器学习(Machine_Learning)_深度学习(_Alg
08-23
2018_2019_校招_春招_秋招_算法_机器学习(Machine_Learning)_深度学习(_Algorithm_Interview_Notes-Chinese
基于springboot和vue的 学生心理咨询评估系统源码 （优秀毕业设计源码）
08-23
1. 学生心理咨询评估系统代码说明：经导师指导并认可通过的98分毕设项目代码。 2.适用对象：本代码学习资料适用于计算机、电子信息工程、数学等专业正在做毕设的学生，需要项目实战练习的学习者，也适用于课程设计、期末大作业。 3.技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 4. 作者介绍：大厂码农，java领域创作者，阿里云开发社区乘风者计划专家博主，专注于大学生项目实战开发，文章底部有博主联系方式，更多优质系统、项目定制请私信。 5. 最新计算机软件毕业设计选题大全: https://blog.csdn.net/weixin_45630258/article/details/135901374
Linux听课笔记-个人基础学习记录
最新发布
08-23
Linux听课笔记-个人基础学习记录
黑马程序员多线程练习题
08-23
- *1* *2* *3* [黑马程序员——多线程10：多线程相关练习](https://blog.csdn.net/axr1985lazy/article/details/48186039)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值