多线程全面分析+代码示例_多线程导致代码

多线程全面分析+代码示例

观看B站动力节点视频后总结笔记

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

​ 进程是一个应用程序/软件。

​ 线程是一个进程中的执行场景/执行单元

​ 一个进程可以启动多个线程。

2.对于Java程序来说，当在DOS命令窗口中输入：

​ java hello world回车之后，会先启动JVM，而JVM就是一个进程。

​ JVM再启动一个主线程调用main方法。

​ 同时再启动一个垃圾回收线程负责看护，回收垃圾。

​ 最起码，现在的Java程序中至少有两个线程并发：

​ 一个是垃圾回收线程，一个是执行main方法的主线程。

3.进程和线程是什么关系？举个例子

​ 阿里巴巴：进程

​ 马云：阿里巴巴的一个线程

​ 童文红：阿里巴巴的一个线程

​ 京东：进程

​ 刘强东：京东的一个线程

​ 奶茶妹妹：京东的一个线程

​ 进程可以看作是现实生活当中的公司。

​ 线程可以看作是公司当中的某个员工。

​ 注意：进程A和进程B的内存独立不共享。（阿里巴巴和京东资源不共享）

​ 举个例子：魔兽游戏是一个进程，网易云音乐是一个进程。两个进程是独立的，不共享资源。

​ 线程A和线程B呢？在Java语言中：线程A和线程B，堆内存和方法区内存共享。但是栈内存独立，一个线程一个栈。

​ 假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。

​ 火车站可以看成一个进程，每个售票窗口看成一个线程。我在1购票，你在2购票。互不用等，提高效率。Java中之所以有多线程机制，目的就是为了提高程序的处理效率。

4.思考一个问题：

​ 使用了多线程机制之后，main方法结束，是不是有可能程序也没有结束，main方法结束了只是主线程结束了，主栈空了，其他的栈可能还在压栈，弹栈。

5.分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发吗？

​ 什么是真正的多线程并发？t1线程执行t1的，t2线程执行t2的，互不干涉。

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

6.Java语言中，实现线程的方式有两种。

​ Java支持多线程机制，并且Java已经将多线程实现了，我们继承就完事了。

​ 第一种方式：编写一个类，直接继承Java.lang.Thread，重写run方法。

public class MyThread extends Thread{
    public void run(){
        
    }
}
MyThread t= new MyThread();
t.start();
1
2
3
4
5
6
7

​ 第二种方法： 编写一个类，实现java.lang.Runnable接口，实现run方法。

public class MyRunnable implements Runnable{
    //定义一个可运行的类
    public void run(){
        
    }
    //创建线程对象
    Thread t=new Thread(new MyRunnable());
    //启动线程
    t.start();
}
1
2
3
4
5
6
7
8
9
10

7.第一种方式test

package Thread;
/*
* 实现线程的第一种方式：
*       编写一个类，直接继承Java.lang.Thread,重写run方法
*
* 怎么创建线程对象？ new就行了
* 怎么启动线程呢？  调用线程对象的start()方法
*
* 注意：亘古不变的道理：
*         方法体中的代码永远都是自上而下的顺序依次逐行执行的。
*
* */
public class ThreadTest02 {
    public static void main(String[] args) {
        //这里是main方法，这里的代码属于主线程，在主栈中运行。
        //新建一个分支线程对象
        MyThread myThread=new MyThread();
        //启动线程
        //start（）方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，
        // 这段代码完成任务后，瞬间就结束了。
        //这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start方法就结束了。线程就启动成功了
        //启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
        //run方法在分支栈的栈底部，run和main是平级的。
        myThread.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);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

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

8.匿名内部类的方式

package Thread;

/*
* 采用匿名内部类可以吗？
* */
public class ThreadTest04 {
    public static void main(String[] args) {
        //创建线程对象，采用匿名内部类方式
        //这是一个通过没有名字的类，new出来的对象。
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <1000 ; i++) {
                    System.out.println("分支-----"+i);
                }
            }
        });
        t.start();
        for (int i = 0; i <1000 ; i++) {
            System.out.println("主-----"+i);
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

9.线程生命周期

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

10.获取线程的名字

package Thread;

/*
*1.怎么获取当前线程对象？
* static Thread currentThread()
* Thread t=Thread.currentThread();
* 返回值t就是当前线程。
* 2.获取线程对象的名字  t.getName()
*3.修改线程对象的名字  t.setName("线程名字")
* 默认名字为Thread-0 Thread-1
* */
public class ThreadTest05 {
    public static void main(String[] args) {

        //这个代码出现在主线程中，所以当前线程就是主线程
        Thread currentThread=Thread.currentThread();
        System.out.println(currentThread.getName());

        //创建线程对象
        MyThread2 t=new MyThread2();
        //设置线程名字
//        t.setName("ttt");
        //获取线程名字
        System.out.println(t.getName());//默认为Thread-0
        //启动线程
        t.start();
        MyThread2 t2=new MyThread2();
        System.out.println(t2.getName());

    }
}
class  MyThread2 extends Thread{
    public void run(){
        Thread currentThread=Thread.currentThread();
        System.out.println(currentThread.getName());
        for (int i = 0; i < 100; i++) {
            System.out.println("分支"+i);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

11.线程的sleep方法

package Thread;

/*
* Thread的sleep()方法
* static void sleep(long millis)
* 1.静态方法
* 2.参数是毫秒
* 3.作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它的线程使用。
*          出现在哪里，让对应的thread进入休眠。
* 4.Thread.sleep 方法可以做到这样的效果：
*   间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。
* */
public class ThreadTest06 {
    public static void main(String[] args) throws InterruptedException {

        //让当前线程进行睡眠，睡眠五秒钟
        /*Thread.sleep(1000*5);
        System.out.println("hello world！");*/
        for (int i = 0; i <10 ; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
            Thread.sleep(1000);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

12.sleep方法的面试题

package Thread;
/*
* 关于Thread.sleep()方法的一个面试题：
* */
public class ThreadTest07 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new MyThread3();
        t.setName("t");
        t.start();
        //问题：这行代码会让线程t进入休眠状态吗？
        //

        t.sleep(1000*5);//这段代码执行的时候还是会转换成：Thread.sleep(1000*5);(sleep是静态方法！)
        //这段代码的作用是让当前线程进入休眠,也就是说让main方法进入休眠
        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);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

13.终止线程睡眠

package Thread;
/*
* sleep睡眠时间太久了，如果希望半道上醒来，你应该怎么办？也就是说怎么叫醒一个正在睡眠的线程
* 注意：这个不是中断线程的执行，是终止线程的睡眠。
* */
public class ThreadTest08 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(new MyRunnable());
        t.setName("t");
        t.start();
        //希望五秒之后，t线程醒来
        Thread.sleep(1000*5);
        //中断t线程的睡眠(这种中断睡眠的方式依靠的是Java的异常处理机制。)
        t.interrupt();
    }


}
class MyRunnable implements Runnable{

    //run方法中的异常不可以throws，只可以try-catch，
    //因为run方法在父类中没有抛出任何异常，子类不可以比父类抛出更多的异常
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->begin");
        try {
            Thread.sleep(1000*60*60*24*365);//这里不可以throws，子类重写不能抛出更多的异常
        } catch (InterruptedException e) {
            e.printStackTrace();//打印信息
        }
        System.out.println(Thread.currentThread().getName()+"--->end ");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

14.强行终止线程的进行

package Thread;
/*
* 在java中怎么强行终止一个线程。
*
*
* */
public class ThreadTest09 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(new MyRunnable3());
        t.setName("t");
        t.start();
        //模拟5秒
        Thread.sleep(1000*5);
        //5秒后强制终止t线程
        t.stop();//已经过时，不建议使用。
        //缺点：会丢失数据！因为这种方式是直接将线程杀死，线程没有保存的数据将会丢失，不建议使用。

    }

}
class MyRunnable3 implements Runnable{

    @Override
    public void run() {

        for (int i = 0; i <10 ; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

15.合理的终止一个线程

package Thread;
/*
* 怎么合理的终止一个线程的执行，这种方法是很常见的
*
* */
public class ThreadTest10 {
    public static void main(String[] args) throws InterruptedException {
        MyRunnable4 myRunnable4= new MyRunnable4()
        Thread t=new Thread(myRunnable4);
        t.setName("t");
        t.start();
        //模拟五秒
        Thread.sleep(1000*5);
        //终止线程
        // 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。
        myRunnable4.run=false;
    }
}
class  MyRunnable4 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就结束了。你在结束之前还有什么没保存的，在这里可以保存呀
                //终止线程
                return;
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

16.线程调度（概念了解）

常见的线程调度模型有哪些？

​ 1.抢占式调度模型

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

​ 2.均分式调度模型

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

Java中提供了哪写方法是和线程调度有关系的呢？

​ 实例方法：void setPriority (int newPriority)设置线程优先级

​ int getPriority()获取线程优先级

​ 最低优先级是1，默认优先级是5，最高优先级是10。优先级比较高的获取CPU时间片可能会多一些（但也不完全，大概率是多的）。

​ void join()合并线程

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

17.线程优先级

package Thread;
/**
 * 了解：关于线程优先级
 */

public class ThreadTestd11 {
    public static void main(String[] args) {
      /*  System.out.println("最高优先级"+Thread.MAX_PRIORITY);
        System.out.println("最低优先级"+Thread.MIN_PRIORITY);
        System.out.println("默认优先级"+Thread.NORM_PRIORITY);*/
        //获取当前线程对象，获取当前线程的优先级
        Thread currentThread=Thread.currentThread();
        System.out.println(currentThread.getName()+"线程的默认优先级："+currentThread.getPriority());

        Thread t=new Thread(new MyRunnable5());
        t.setName("t");
        t.start();

    }
}
class MyRunnable5 implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"默认优先级"+Thread.currentThread().getPriority());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

18.线程让位

package Thread;
/*
* 让位：当前线程暂停，回到就绪状态，让给其他线程。
* 静态方法：Thread yield()
* */
public class ThreadTest12 {
    public static void main(String[] args) {
        Thread t=new Thread(new MyRunnable6());
        t.setName("t");
        t.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }

}
class MyRunnable6 implements Runnable{

    @Override
    public void run() {
        //每一百个让位一次

        for (int i = 0; i < 1000; i++) {
            if(i%100==0){
                Thread.yield();
            }

            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

19.线程合并

package Thread;

public class ThreadTest13 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("main begin");
        Thread t=new Thread(new MyRunnbable7());
        t.setName("t");
        t.start();

        //合并线程：栈之间协调
        t.join();//t合并到当前线程，当前线程受阻塞，t线程执行直到结束
        System.out.println("main over");
    }

}
class MyRunnbable7 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

20.线程安全（数据安全问题）

为什么这个是重点？

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

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

什么情况下数据在多线程并发的环境下会存在安全问题呢？

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

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

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

​ 线程排队执行（不能并发）。 用排队执行解决线程安全问题

​ 这种机制被称为：线程同步机制。实际上就是排队

​ 线程会失去牺牲一部分效率，没办法，数据安全第一位。只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事。（并发虽然效率高，但是有时候会不安全）

​ 异步编程模型：线程t1和线程t2，各自执行各自的。

​ 同步编程模型：线程t1和线程t2，在线程t1执行的时候，必须等待线程t2执行结束。两个线程之间发生了等待关系。

银行取款例子

package ThreadSafe2;

//银行账户
//使用线程同步解决线程安全问题
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) throws InterruptedException {

        //以下这些代码必须是线程排队的,不能并发
        //一个线程把这里的代码全部执行结束之后,另一个线程才可以进来.

        /*
        * 线程同步机制的语法是:
        *           synchronized(){
        *               //线程同步代码块
        *       }
        *  synchronized()后面小括号传入的数据是相当关键的,这个数据必须是多线程共享的数据.才能达到多线程排队
        * 小括号中写什么?
        *       那要看你想让哪些线程同步
        *       假设t1,t2,t3,t4,t5  五个线程
        *       你只希望t1,t2,t3排队,t4,t5不排队,怎么办?
        *       你一定要在()中写一个t1,t2,t3共享的对象,而这个对象对于t4,t5来说是不共享的
        *
        *      这里的共享对象是账户对象.账户对象是共享的,那么this就是账户对象
        *      这里不一定是this,这里只要是多线程共享的那个对象就行
        *	在Java语言中，任何一个对象都有一把锁，这把锁就是一个标记。
        *   100个对象，100把锁
        * */
        synchronized (this){
            double  before=this.getBalance();
            double after=before-money;
            Thread.sleep(1000);
            this.setBalance(after);
        }
    }
}
public class AccountThread extends Thread {
    //两个线程必须共享同一个线程对象.

    private Account act;

    //通过构造方法传递过来账户对象.
    public AccountThread(Account act){
        this.act=act;
    }
    public void run(){

        //run方法的执行表示取款操作。
        double money=5000;
        //取款
        try {
            act.withdraw(money);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"对"+act.getActno()+"取款成功!余额为:"+act.getBalance());
    }
}

public class Test {
    public static void main(String[] args) {
        //创建账户对象(只创建一个)
        Account account=new Account("act--01",10000);
        Thread t1=new AccountThread(account);
        Thread t2=new AccountThread(account);
        t1.setName("T1");
        t2.setName("T2");
        t1.start();
        t2.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

21.哪些变量有线程安全问题

Java中有三大变量

实例变量：在堆中

静态变量：在方法区中

局部变量：在栈中 永远不会存在线程安全问题！ 因为局部变量不共享

如果使用局部变量的话：建议使用StringBuilder。因为局部变量不存在线程安全问题。选择StringBuilder。StringBuffer 效率比较低。

ArrayList是非线程安全的，Vector是线程安全的。HashMap HashSet是非线程安全的。Hashtable是线程安全的。

总结：synchronized有三种写法：

​ 第一种：同步代码块：灵活

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

​ 第三种：在静态方法上使用synchronized，表示找类锁，类锁永远只有一把，一百个对象也只有一把。

22.死锁

死锁代码例子

package DeadLock;
/*
* 死锁代码要会写,一般面试官要求你会写.
* 只有会写,才会在以后的开发中注意这个事.
* 因为死锁很难调试
* */
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){
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

如何解决线程安全问题？一上来就synchronized？

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

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

​ 第二种方案：如果必须得是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了（一个线程一个对象）。

​ 第三种方案：如果不能使用局部变量，对象也不可以创建多个。这时只可以选择synchronized

23.守护线程

Java语言中线程分为两大类：

一类是：用户线程

一类是：守护线程（后台线程） 代表性：垃圾回收线程

守护线程的特点：

一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。

注意：主线程main方法是一个用户线程。

守护线程用在什么地方？

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

package Thread;
/*
* 实现守护线程
* */
public class ThreadTest14 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new BakDataThread();
        t.setName("备份数据线程");
        //启动线程之前,将线程设置为守护线程
        t.setDaemon(true);
        t.start();

        //主线程:主线程是用户线程
        for (int i = 0; i <10 ; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
            Thread.sleep(1000);
        }
    }
}
class BakDataThread extends Thread{
    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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

24.定时器

定时器的作用：间隔特点的时间，执行特定的程序。

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

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

可以使用sleep方法，睡眠，设置睡眠时间，每到特定时间醒来，这样的方式是最原始的定时器。

在java类库中已经写好了一个定时器，java.util.Timer,可以直接用。不过这样的方式在目前开发中也不怎么用，因为现在的很多高级框架都是支持定时任务的，在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。

package Thread;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/*
*使用定时器指定定时任务
* */
public class TimerTest {

    public static void main(String[] args) throws Exception{
        //创建定时器对象
        Timer timer=new Timer();
        //Timer timer=new Timer(true);守护线程的方式

        //指定定时任务
        //schedule(定时任务,第一次执行时间,间隔多久执行一次);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date firsttime=sdf.parse("2021-03-27 18:23:30");
        timer.schedule(new LogTimeTask(),firsttime,1000*10);
        /*timer.schedule(new TimerTask(){
                匿名内部类也可以
            @Override
            public void run() {

            }
        },firsttime,1000*10);*/
    }
}
//编写一个定时任务类
class LogTimeTask 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+"完成了一次数据备份");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

25.实现线程的第三种方式

实现Callable接口。（JDK新特性）
这种方式实现的线程可以获取线程的返回值，之前讲解的那两种方法无法获取线程的返回值的，因为run方法返回void。
思考：系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，我们怎么拿到这个执行结果呢？使用第三种方式：实现Callable接口方式

package Thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/*
* 实现线程的第三种方式：实现callable接口
*
* */
public class ThreadTest15 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
    //第一步：创建一个“未来任务类”对象
        //参数非常重要，需要给一个Callable接口实现类对象。
        FutureTask task=new FutureTask(new Callable() {
            //call方法相当于run方法，只不过call有返回值
            //线程执行一个任务，执行之后可能会有一个执行结果
            //模拟执行
            @Override
            public Object call() throws Exception {
                System.out.println(" call method  begin");
                Thread.sleep(1000*10);
                System.out.println("call method end");
                int a=100,b=200;
                return a+b;//自动装箱（300为integer）
            }
        });
        Thread t=new Thread(task);
        t.start();
        //这里是main方法，在主线程中，在主线程中怎么获取t的执行结果。
        //get方法的执行会导致当前线程阻塞，
        Object obj= task.get();
        System.out.println("线程执行结果："+obj);
        //main方法这里的程序要想执行必须等待get（）方法的结束。
        //而get方法可能需要执行很久，因为get方法是为了拿另一个线程的执行结果，而另一个线程执行是需要时间的。

        System.out.println("hello world");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

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

第一：wait和notify方法不是线程对象的方法，是Java中任何一个Java对象都有的方法，因为这两个方法是Object类中自带的。wait方法和notify方法不是通过线程对象调用
第二：wait()方法作用？
Objcet o = new Objcet();
o.wait();
表示：让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。
第三：notify()方法的作用？

​ Object o =new Object();

​ o.notify();

​ 表示：唤醒正在o对象上等待的线程。

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

生成者和消费者模式是为了专门解决某个特定需求的。

图示：