21.多线程

Luer笔达

已于 2024-02-15 21:36:13 修改

阅读量72

点赞数

分类专栏： JavaSE 文章标签： java

于 2023-07-10 14:47:47 首次发布

本文链接：https://blog.csdn.net/qq_26126363/article/details/131637019

版权

JavaSE 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

一、多线程

1、什么是进程？什么是线程？

进程是一个应用程序（1个进程是一个软件），线程是一个进程中的执行场景/执行单元，一个进程可以启动多个线程。

对于java程序来说，当在DOS命令窗口中输入：java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。JVM再启动一个主线程调用main方法。同时再启动一个垃圾回收线程负责看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。

2、进程和线程是什么关系？举个例子

阿里巴巴：进程
马云：阿里巴巴的一个线程
童文红:阿里巴巴的一个线程

京东：进程
强东：京东的一个线程
妹妹：京东的一个线程

进程可以看做是现实生活当中的公司。线程可以看做是公司当中的某个员工。

注意：
进程A和进程B的内存独立不共享。（阿里巴巴和京东资源不会共享的！）
魔兽游戏是一个进程，酷狗音乐是一个进程，这两个进程是独立的，不共享资源。

线程A和线程B呢？
在java语言中：线程A和线程B，堆内存和方法区内存共享。但是栈内存独立，一个线程一个栈。
假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。

火车站，可以看做是一个进程。火车站中的每一个售票窗口可以看做是一个线程。我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。所以多线程并发可以提高效率。java中之所以有多线程机制，目的就是为了提高程序的处理效率。

思考一个问题：使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束。
main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈。

分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发吗？
对于多核的CPU电脑来说，真正的多线程并发是没问题的。
4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。

什么是真正的多线程并发？
t1线程执行t1的。t2线程执行t2的。t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发。

单核的CPU表示只有一个大脑：不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是：多个事情同时在做！！！！！

例如：
线程A：播放音乐
线程B：运行魔兽游戏
线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，给我们的感觉是同时并发的。

例如：电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，人类的眼睛产生了错觉，感觉是动画的。这说明人类的反应速度很慢，就像一根钢针扎到手上，到最终感觉到疼，这个过程是需要“很长的”时间的，在这个期间计算机可以进行亿万次的循环。所以计算机的执行速度很快。

二、java语言中，实现线程有三种方式

java支持多线程机制。并且java已经将多线程实现了，我们只需要继承就行了。

1、编写一个类，直接继承java.lang.Thread，重写run方法

        // 定义线程类
       public class MyThread extends Thread{
           public void run(){

           }
       }
       // 创建线程对象
       MyThread t = new MyThread();
       // 启动线程。
       t.start();

public class ThreadTest01 {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

理解线程的run();

理解线程的start();

2、编写一个类，实现java.lang.Runnable接口，实现run方法。

// 定义一个可运行的类
       public class MyRunnable implements Runnable {
           public void run(){

           }
       }
       // 创建线程对象
       Thread t = new Thread(new MyRunnable());
       // 启动线程
       t.start();

public class ThreadTest02 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
        for(int i = 0; i < 100; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

也可以写为匿名内部类的风格：

public class ThreadTest03 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0; i < 100; i++){
                    System.out.println("分支线程--->" + i);
                }
            }
        });
        t.start();
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

3、实现Callable接口。（JDK8新特性）

这种方式实现的线程可以获取线程的返回值。之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。

思考：系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，我们怎么能拿到这个执行结果呢？使用第三种方式：实现Callable接口方式。

public class ThreadTest {
    public static void main(String[] args) {
        FutureTask ft = new FutureTask(new MyCallable());
        Thread t1 = new Thread(ft);
        t1.start();
        
        
        // 这里是main方法，这是在主线程中。
        // 在主线程中，怎么获取t线程的返回结果？
        // get()方法的执行会导致“当前线程阻塞”
        Object obj = task.get();
        System.out.println("线程执行结果:" + obj);

        // main方法这里的程序要想执行必须等待get()方法的结束
        // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
        // 另一个线程执行是需要时间的。
        主线程main中的code.....
        
    }
}
class MyCallable implements Callable {
    @Override
    public Object call() throws Exception {
        //call()方法就相当于run方法。只不过这个有返回值
        code....
        return xxx;
    }
}

注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。

理解一个线程一个栈：

三、关于线程对象的生命周期？

新建状态、就绪状态、运行状态、阻塞状态、死亡状态

四、线程的调度

1、获取线程的方法

1）获取当前线程对象

Thread t = Thread.currentThread();
返回值t就是当前线程。

2）获取线程对象的名字

String name = 线程对象.getName();

3）修改线程对象的名字

线程对象.setName("线程名字");

当线程没有设置名字的时候，默认的名字有什么规律？（了解一下）

Thread-0
Thread-1
Thread-2
Thread-3
.....

4）线程的休眠

static void sleep(long millis)
是个静态方法，参数是毫秒。

作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。
这行代码出现在A线程中，A线程就会进入休眠。
这行代码出现在B线程中，B线程就会进入休眠。

Thread.sleep()方法，可以做到这种效果：
间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。

动手实验：让线程每隔一秒输出一条。

public class ThreadTest02 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread02());
        t1.start();
    }
}

class MyThread02 implements Runnable {

    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}

关于Thread.sleep()的面试题：

public class ThreadTest07 {
    public static void main(String[] args) {
        // 创建线程对象
        Thread t = new MyThread3();
        t.setName("t");
        t.start();

        // 调用sleep方法
        try {
            // 问题：这行代码会让线程t进入休眠状态吗？
            t.sleep(1000 * 5); // 在执行的时候还是会转换成：Thread.sleep(1000 * 5);
                                     // 这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠。
                                     // 这样代码出现在main方法中，main线程睡眠。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 5秒之后这里才会执行。
        System.out.println("hello World!");
    }
}

class MyThread3 extends Thread {
    public void run(){
        for(int i = 0; i < 10000; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

5）线程的唤醒

void interrupt()
是个实例方法，唤醒一个正在睡眠的线程。

动手实验：让分支线程刚开始执行，突然休眠一年，让主线程休眠五秒后唤醒分支线程。

public class ThreadTest03 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread03());
        t1.start();
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.interrupt();

    }
}

class MyThread03 implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "start....");
        try {
            Thread.sleep(1000 * 60 * 60 * 24 * 365);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "end....");
    }
}

6）线程的终止方式1

void stop()
是个实例方法，终止一个线程。

缺点：容易丢失数据。因为这种方式是直接将线程杀死了，不建议使用。

7）线程的终止方式2

打标记：

public class ThreadTest {
    public static void main(String[] args) {
        MyRunable r = new MyRunable();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();

        // 模拟5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终止线程
        // 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。
        r.run = false;
    }
}

class MyRunable implements Runnable {

    // 打一个布尔标记
    boolean run = true;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            if(run){
                System.out.println(Thread.currentThread().getName() + "--->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                // return就结束了，你在结束之前还有什么没保存的。
                // 在这里可以保存呀。
                //save....

                //终止当前线程
                return;
            }
        }
    }
}

2、常见的线程调度模型

抢占式调度模型：
那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。java采用的就是抢占式调度模型。

均分式调度模型：
平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。平均分配，一切平等。有一些编程语言，线程调度模型采用的是这种方式。

3、线程调度有关的方法

1）实例方法：

void setPriority(int newPriority)
设置线程的优先级；

int getPriority()
获取线程优先级；
最低优先级1，Thread.MIN_PRIORITY
默认优先级是5，Thread.NORM_PRIORITY
最高优先级10，Thread.MAX_PRIORITY
优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）

public class ThreadTest05 {
    public static void main(String[] args) {
//        System.out.println("最低优先级：" + Thread.MIN_PRIORITY);
//        System.out.println("最高优先级：" + Thread.MAX_PRIORITY);
//        System.out.println("默认优先级：" + Thread.NORM_PRIORITY);

//        System.out.println("main线程优先级：" + Thread.currentThread().getPriority());
        Thread.currentThread().setPriority(1);
        Thread t1 = new Thread(new MyRunnable());
        t1.setPriority(10);
        t1.start();
        for(int i = 0; i < 1000; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}
class MyRunnable implements Runnable{

    @Override
    public void run() {
//        System.out.println("分支线程优先级：" + Thread.currentThread().getPriority());
        for(int i = 0; i < 1000; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

void join()
合并线程

public class ThreadTest07 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable03());
        t1.start();
        try {
            t1.join();// 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}
class MyRunnable03 implements Runnable{

    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

2）静态方法：

static void yield()
让位方法；
暂停当前正在执行的线程对象，并执行其他线程。
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
注意：在回到就绪之后，有可能还会再次抢到。

public class ThreadTest06 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable02());
        t1.start();
        for(int i = 1; i <= 1000; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}
class MyRunnable02 implements Runnable{

    @Override
    public void run() {
        for(int i = 1; i <= 1000; i++){

            if(i % 10 == 0){
                Thread.yield();
            }
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

五、关于多线程并发环境下，数据的安全问题

1、为什么这个是重点？

以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。

最重要的是：你要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的。（重点：*****）

2、什么时候数据在多线程并发的环境下会存在安全问题呢？

三个条件：
条件1：多线程并发。
条件2：有共享数据。
条件3：共享数据有修改的行为。

满足以上3个条件之后，就会存在线程安全问题。

动手实验：用两个线程对同一个账户取钱，看有什么问题

public class Account {
    private String actNo;
    private double balance;

    public Account() {
    }

    public Account(String actNo, double balance) {
        this.actNo = actNo;
        this.balance = balance;
    }

    public String getActNo() {
        return actNo;
    }

    public void setActNo(String actNo) {
        this.actNo = actNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public void withDraw(double money){
        double before = this.getBalance();
        double after = before - money;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setBalance(after);
    }
}

public class AccountThread extends Thread{
    private Account account;

    public AccountThread() {
    }

    public AccountThread(Account account) {
        this.account = account;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        double money = 5000;
        account.withDraw(money);
        System.out.println(Thread.currentThread().getName() + "线程在账户[" + this.account.getActNo() + "]中成功取款" + money + "元，账户所剩余额为：" + this.account.getBalance());
    }
}

public class Test {
    public static void main(String[] args) {
        Account act = new Account("1001", 10000);
        AccountThread t1 = new AccountThread(act);
        AccountThread t2 = new AccountThread(act);

        t1.setName("t1");
        t2.setName("t2");

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

    }
}

3、怎么解决线程安全问题呢？

当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？线程排队执行。（不能并发）。用排队执行解决线程安全问题。这种机制被称为：线程同步机制。

专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。

怎么解决线程安全问题呀？使用“线程同步机制”。

线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

4、说到线程同步这块，涉及到这两个专业术语：

异步编程模型：
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。其实就是：多线程并发（效率较高。）异步就是并发。

同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型。效率较低。线程排队执行。同步就是排队。

5、java中哪些变量会有线程安全问题？

Java中有三大变量？【重要的内容。】

实例变量：在堆中。

静态变量：在方法区。

局部变量：在栈中。

以上三大变量中：
局部变量永远都不会存在线程安全问题。因为局部变量不共享。（一个线程一个栈。）局部变量在栈中。所以局部变量永远都不会共享。
实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。

局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。

对于字符串，如果使用局部变量的话，建议使用StringBuilder。因为局部变量不存在线程安全问题。StringBuffer效率比较低。

对于集合，ArrayList是非线程安全的。Vector是线程安全的。HashMap、HashSet是非线程安全的。Hashtable是线程安全的。

6、用 synchronized来解决线程安全问题

synchronized有三种写法：

第一种：同步代码块
灵活
           synchronized(线程共享对象){
               同步代码块;
           }

动手实验：修改上面的动手实验，加入synchronized

public void withDraw(double money){
        synchronized (this) {
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }
    }

第二种：在实例方法上使用synchronized
不灵活
        表示共享对象一定是this
        并且同步代码块是整个方法体。

第三种：在静态方法上使用synchronized
表示找类锁。
类锁永远只有1把。
就算创建了100个对象，那类锁也只有一把。

对象锁：1个对象1把锁，100个对象100把锁。
类锁：100个对象，也可能只是1把类锁。

关于synchronized的面试题1：


// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    //不需要，因为doOther()方法没有synchronized
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc = new MyClass();

        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
        t2.start();
    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc){
        this.mc = mc;
    }
    public void run(){
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }
    }
}

class MyClass {
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }
    public void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

关于synchronized的面试题2：

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    //需要
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc = new MyClass();

        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
        t2.start();
    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc){
        this.mc = mc;
    }
    public void run(){
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }
    }
}

class MyClass {
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }
    public synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

关于synchronized的面试题3：

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    //不需要，因为MyClass对象是两个，两把锁。
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
        t2.start();
    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc){
        this.mc = mc;
    }
    public void run(){
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }
    }
}

class MyClass {
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }
    public synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

关于synchronized的面试题4：

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    //需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把。
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
        t2.start();
    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc){
        this.mc = mc;
    }
    public void run(){
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }
    }
}

class MyClass {
    // synchronized出现在静态方法上是找类锁。
    public synchronized static void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }
    public synchronized static void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

死锁代码的写法：

/*
死锁代码要会写。
一般面试官要求你会写。
只有会写的，才会在以后的开发中注意这个事儿。
因为死锁很难调试。
 */
public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();

        // t1和t2两个线程共享o1,o2
        Thread t1 = new MyThread1(o1,o2);
        Thread t2 = new MyThread2(o1,o2);

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

class MyThread1 extends Thread{
    Object o1;
    Object o2;
    public MyThread1(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){

            }
        }
    }
}

class MyThread2 extends Thread {
    Object o1;
    Object o2;
    public MyThread2(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){

            }
        }
    }
}

7、我们以后开发中应该怎么解决线程安全问题？

是一上来就选择线程同步吗？synchronized

不是，synchronized会让程序的执行效率降低，用户体验不好。系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择线程同步机制。

第一种方案：
尽量使用局部变量代替“实例变量和静态变量”。

第二种方案：
如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了。）

第三种方案：
如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制。

六、守护线程

java语言中线程分为两大类：用户线程和守护线程（后台线程）。
其中具有代表性的就是：垃圾回收线程（守护线程）。

守护线程的特点：
一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。
注意：主线程main方法是一个用户线程。

守护线程用在什么地方呢？
每天00:00的时候系统数据自动备份。这个需要使用到定时器，并且我们可以将定时器设置为守护线程。让它一直在那里看着，每到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。

将一个线程设置为守护线程：
void setDaemon(boolean on)：实例方法，将一个用户线程设置为守护线程；

动手实验：测试没有开启守护线程时用户线程结束，分支线程不结束；测试开启守护线程时用户线程一结束，守护线程也随之结束。

public class DaemonTest01 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.setName("t1");
        t1.setDaemon(true);
        t1.start();
        for(int i = 0; i < 10; i++){

            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}
class MyRunnable implements Runnable{

    @Override
    public void run() {
        int i = 0;
        while(true){
            System.out.println(Thread.currentThread().getName() + "--->" + i++);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

七、定时器

1、定时器的作用：

间隔特定的时间，执行特定的程序。

例如：每周要进行银行账户的总账操作，每天要进行数据的备份操作。

2、定时器的实现方式

在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，那么在java中其实可以采用多种方式实现：

1）可以使用sleep方法，睡眠，设置睡眠时间，每到这个时间点醒来，执行任务。这种方式是最原始的定时器。（比较low）

2）在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。

public class TimerTest {
    public static void main(String[] args) throws Exception {

        // 创建定时器对象
        Timer timer = new Timer();
        //Timer timer = new Timer(true); //守护线程的方式

        // 指定定时任务
        //timer.schedule(定时任务, 第一次执行时间, 间隔多久执行一次);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime = sdf.parse("2020-03-14 09:34:30");
        timer.schedule(new LogTimerTask() , firstTime, 1000 * 10);


        //匿名内部类方式
        /*
        timer.schedule(new TimerTask(){
            @Override
            public void run() {
                // code....
            }
        } , firstTime, 1000 * 10);
        */
    }
}

// 编写一个定时任务类
// 假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask {

    @Override
    public void run() {
        // 编写你需要执行的任务就行了。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strTime = sdf.format(new Date());
        System.out.println(strTime + ":成功完成了一次数据备份！");
    }
}

在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。

八、关于Object类中的wait和notify方法（生产者和消费者模式！）

1、wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的。

wait方法和notify方法不是通过线程对象调用，既不是这样调用的：线程对象.wait()，也不是这样调用的：线程对象.notify()..。

2、wait()方法作用？

Object o = new Object();
o.wait();
表示：让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。

3、notify()方法作用？

Object o = new Object();
o.notify();

表示：唤醒正在o对象上等待的线程。
还有一个notifyAll()方法：这个方法是唤醒o对象上处于等待的所有线程。

4、wait()和notify()方法的理解：

5、使用wait()和notify()方法实现生产者消费者模式

Luer笔达

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
21.多线程

进程是一个应用程序（1个进程是一个软件），线程是一个进程中的执行场景/执行单元，一个进程可以启动多个线程。对于java程序来说，当在DOS命令窗口中输入：java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。JVM再启动一个主线程调用main方法。同时再启动一个垃圾回收线程负责看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。
复制链接

扫一扫