两万字带你了解Java多线程(详细大总结)

三万字带你了解那些年面过的Java八股文 目录????前言1️⃣Java基础知识????基础知识导图????IO流????Lambda????&和&&的区别?????在java中如何跳出当前的多重循环?????面向对象的三大特征????"=="和equals方法究竟有什么区别?????三个与取整有关的方法????Java中运算符✨重载和重写的区别?????String和StringBuffuer、StringBuilder的区别?????java中有几种方法实现一个线程?用什么关键字修饰同步方法?stop()和suspend 阅读详情

目录

多线程概念

什么是进程?
进程是一个应用程序(1个进程是一个软件)。

什么是线程?
线程是一个进程中的执行场景/执行单元。一个进程可以启动多个线程。

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

进程可以看做是现实生活当中的公司,线程可以看做是公司当中的某个员工。
注意:进程A和进程B的内存独立不共享。

线程A和线程B呢?
在java语言中:
线程A和线程B,堆内存和方法区内存共享。但是栈内存独立,一个线程一个栈。

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

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

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

实现线程的第一种方式

实现线程的第一种方式:
编写一个类,直接继承java.lang.Thread,重写run方法。
怎么创建线程对象?new就行了。
怎么启动线程呢?调用线程对象的start()方法。
注意:亘古不变的道理:
方法体当中的代码永远都是自上而下的顺序依次逐行执行的。

代码示例

public class 实现线程的第一种方式 {
 
    public static void main(String[] args) {
 
        // 这里是main方法,这里的代码属于主线程,在主栈中进行
        // 新建一个分支对象
        MyThresd myThresd = new MyThresd();

        //start()方法的作用是:启动一个分支线程,在JVM中开辟一个新的栈空间,这段代码任务完成后,瞬间就结束了。
        //这段代码的任务只是为了开启一个新的栈空间,只要新的栈空间开出来,start()方法就结束了,线程就启动了。
        //启动成功的线程会自动调用run方法,并且run方法在分支栈的栈底部(压栈)。
        //run方法在分支栈的栈底部,main方法在主栈的栈底部。run和main是平级的。
        myThresd.start();

        //这里的代码还是运行在主线程中
        for (int i = 0; i < 1000; i++) {
 
            System.out.println("主线程-->"+i);
        }
    }
}
class MyThresd extends Thread{
 
    @Override
    public void run() {
 
        //编写程序,这段程序运行在分支路线(分支栈)
        for (int i = 0; i < 1000; i++) {
 
            System.out.println("分支线程-->"+i);
        }
    }
}

 

输出结果

实现线程的第二种方式

第二种方式以接口的方式:编写一个类,实现Runnable接口,里面实现run方法。new一个Thread对象,里面传递的参数是Runnable对象,编写的那个类实现了Runnable,所以直接new这个类的对象传进去。

代码示例

public class 实现线程的第二种方式 {
 
    public static void main(String[] args) {
 
        //创建一个可运行的对象
        //MyRunnable r = new MyRunnable();
        //将可运行的对象封装成一个线程对象
        //Thread t = new Thread(r);

        //上面两步合并到一起的写法
        //Thread构造方法有一个是传递一个Runnable,MyRunnable实现了Runnable,所以传MyRunnable也ok
        Thread thread = new Thread(new MyRunnable());

        //启动线程
        thread.start();

        for (int i = 0; i < 100; i++) {
 
            System.out.println("主线程-->"+i);
        }
        /*//采用匿名内部类的方式
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                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 实现线程的第二种方式 {
 
    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 < 100; i++) {
 
            System.out.println("主线程-->"+i);
        }
    }
}

 

实现线程的第三种方式

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

实现线程的第三种方式:
实现Callable接口
这种方式的优点:可以获取到线程的执行结果。
这种方式的缺点:效率比较低,在获取t线程执行结果的时候,当前线程受阻塞,效率较低

public class 实现线程的第三种方式 {
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
 
        //第一步:创建一个“未来任务类”对象。
        //参数非常重要,需要给一个Callable接口实现类对象。这里使用的是匿名内部类的方式。
        FutureTask task = new FutureTask(new Callable() {
 
            @Override
            public Object call() throws Exception {
  //call()方法相当于run方法,只不过这个有返回值
                //线程执行一个任务,执行之后可能会有一个执行结果
                //模拟执行
            System.out.println("call method begin!");
            Thread.sleep(1000*5);
            System.out.println("call method end!");
            int a = 100;
            int b = 200;
            return a+b; //自动装箱(300结果变成Integer)
            }
        });

        //创建线程对象
        Thread t = new Thread(task);

        //启动线程
        t.start();

        //这里是main方法,这里是在主线程中。
        //在主线程中怎么获取t线程的返回结果呢?
        //get()方法的执行会导致“当前线程阻塞”
        Object o = task.get();
        System.out.println("线程执行结果是:"+o);

        //main方法这里的程序想要执行必须要等get方法结束
        //而get方法可能需要很久。因为get()方法是为了拿到另一个线程的执行结果
        //另一个线程执行是需要时间的。
        System.out.println("hello world!");
    }
}

线程的生命周期

关于线程对象的生命周期

新建状态

就绪状态

运行状态

阻塞状态

这个要记住,面试可能会问。

线程对象的方法

代码演示

public class 线程对象的方法 {
 
    public static void main(String[] args) {
 
        //currentThread:获取当前线程对象
        //thread就是当前线程对象
        //这个代码出现在main方法中,所以当前线程就是主线程
        Thread thread = Thread.currentThread();  // 静态方法
        System.out.println(thread.getName());//main

        //创建线程对象
        MyThread2 t1 = new MyThread2();
        //getName:获取线程名字
        String a = t1.getName();
        System.out.println(a);//Thread-0 默认的
        //setName:修改线程名字
        t1.setName("t1");
        System.out.println(t1.getName()); //t1

        MyThread2 t2 = new MyThread2();
        t2.setName("t2");

        t2.start();
        t1.start();
    }
}
class MyThread2 extends Thread{
 
    @Override
    public void run() {
 
        for (int i = 0; i < 100; i++) {
 
            //thread就是当前线程对象。那么当前线程是谁呢?
            //当t1线程执行run方法,那么这个当前线程就是t1
            //当t2线程执行run方法,那么这个当前线程就是t2。  类似于this 谁调用我 我就是谁
            Thread thread = Thread.currentThread();
            System.out.println(thread.getName()+"-->"+i);
        }
    }
}

执行结果

Sleep方法

举例

 

public class sleep方法 {
 
    public static void main(String[] args) {
 

        //让当前线程进入休眠 失眠五秒
        //这个代码出现在main方法中,当前线程就是主线程!!
        try {
 
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
 
            e.printStackTrace();
        }

        //5秒之后执行这里的代码
        System.out.println("hello world!");

        for (int i = 0; i < 10; i++) {
 
            System.out.println(Thread.currentThread().getName()+"--->"+i);
            //休眠一秒
            //这个方法还是出现在主线程中,所以主线程受阻
            try {
 
                Thread.sleep(1000);
            } catch (InterruptedException e) {
 
                e.printStackTrace();
            }
        }
    }
}

Sleep面试题

 

public class sleep方法面试题 {
 
    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线程睡眠
                                                //5秒后就如就绪状态 抢到执行权 执行hello world
        } catch (InterruptedException e) {
 
            e.printStackTrace();
        }
        System.out.println("hello World!");

    }

}
class MyThread3 extends  Thread{
 
    @Override
    public void run() {
 

        for (int i = 0; i < 10000; i++) {
 
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

终止线程的睡眠

sleep睡眠太久了,如果希望半道上醒来,你应该怎么办呢?也就是说怎么叫醒一个正在睡眠的线程??
注意:这个不是终断线程的执行,是终断线程的睡眠。

/*
sleep睡眠太久 如果希望半道醒来,就要终止睡眠
 */
public class 终止线程的睡眠 {
 
    public static void main(String[] args) {
 
        Thread t = new Thread(new MyRunnable2());
        t.setName("t");
        t.start();

        //希望五秒之后,t线程醒来(五秒之后主线程手里的话干完了,不用争执行权了)
        try {
 
            Thread.sleep(5000);
        } catch (InterruptedException e) {
 
            e.printStackTrace();
        }
        //终止t线程的睡眠( 这种终端睡眠的方法依靠java的异常处理机制)
        t.interrupt();//干扰 一盆冷水过去
    }
}
class MyRunnable2 implements Runnable{
 

    // 重点: run()当中的异常不能throws,只能try catch
    // 因为run()方法在父类中没有抛出任何异常,子类不能比父类抛出更多的异常。
    @Override
    public void run() {
 
        System.out.println(Thread.currentThread().getName()+"--->"+"big");
        try {
 
            //睡眠一年
            Thread.sleep(1000L *60*60*24*365);
        } catch (InterruptedException e) {
 
            //打印异常信息
            e.printStackTrace();
        }
        //一年之后才会执行到这里
        System.out.println(Thread.currentThread().getName()+"--->"+"end");
    }
}

终止一个线程的执行

public class 终止一个线程的执行 {
 
    public static void main(String[] args) {
 
        MyRunable4 r = new MyRunable4();
        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 MyRunable4 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;
            }
        }
    }
}

线程调度(了解)

常见的线程调度模型有哪些?
抢占式调度模型:
那个线程的优先级比较高,抢到的CPU时间片的概率就高一些/多一些。 java采用的就是抢占式调度模型。

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

java中提供了哪些方法是和线程调度有关系的呢

线程优先级

/*
关于线程的优先级
setPriority(): 设置优先级
getPriority(): 获取当前线程对象优先级
默认优先级是5
最低是1
最高是10
 */
public class 线程优先级 {
 
    public static void main(String[] args) {
 
        //main线程的默认优先级是:5
        System.out.println(Thread.currentThread().getName()+"线程的默认优先级是:"+Thread.currentThread().getPriority());

        //设置主线程优先级为1
        Thread.currentThread().setPriority(1);

        Thread t = new Thread(new MyRunnable5());
        t.setPriority(10);
        t.setName("t");
        t.start();
        //优先级较高的,只是抢到的CPU时间片多一些。
        //大概率方向更偏向于优先级比较高的。
        for (int i = 0; i < 10000; i++) {
 
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}
class MyRunnable5 implements Runnable{
 

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

线程让位

/*
让位,当前线程暂停,回到就绪状态,让给其它线程。
静态方法:Thread.yield()
 */

public class 线程让位 {
 
    public static void main(String[] args) {
 
        Thread t = new Thread(new MyRunnable6());
        t.setName("t");
        t.start();
        for (int i = 1; i <= 10000; i++) {
 
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}
class MyRunnable6 implements Runnable{
 

    @Override
    public void run() {
 
        for (int i = 1; i <= 10000; i++) {
 
            if (i%100==0){
 
                Thread.yield(); //当前线程暂停一下,让给主线程
            }
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

线程合并

public class 线程合并 {
 
    public static void main(String[] args) {
 
        System.out.println("main begin");

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

        //线程合并
        try {
 
            t.join(); //t合并到当前线程中,当前线程受阻塞,t线程执行直到结束,当前线程才执行。
        } catch (InterruptedException e) {
 
            e.printStackTrace();
        }

        System.out.println("main over");
    }
}
class MyRunnable7 implements Runnable{
 

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

线程安全(重点)

关于多线程并发环境下,数据的安全问题。
为什么这个是重点?
以后在开发中,我们的项目都是运行在服务器当中,而服务器已经将线程的定义,线程对象的创建,线程的启动等,都已经实现完了。这些代码我们都不需要编写。
最重要的是:你要知道,你编写的程序需要放到一个多线程的环境下运行,你更需要关注的是这些数据在多线程并发的环境下是否是安全的。(重点)

什么时候数据在多线程并发的环境下会存在安全问题呢?
三个条件:
条件1:多线程并发。
条件2:有共享数据。
条件3:共享数据有修改的行为。
满足以上3个条件之后,就会存在线程安全问题。

怎么解决线程安全问题呢?
当多线程并发的环境下,有共享数据,并且这个数据还会被修改,此时就存在线程安全问题,怎么解决这个问题?
线程排队执行。(不能并发)。用排队执行解决线程安全问题。这种机制被称为:线程同步机制。专业术语叫做:线程同步,实际上就是线程不能并发了,线程必须排队执行。

怎么解决线程安全问题?
使用“线程同步机制"。
线程同步就是线程排队了,线程排队了就会牺牲一部分效率,没办法,数据安全第一位,只有数据安全了,我们才可以谈效率。数据不安全,没有效率的事儿。

说到线程同步这块,涉及到这两个专业术语:
异步编程模型:
线程t1和线程t2,各自执行各自的,t1不管t2,t2不管t1,谁也不需要等谁,这种编程模型叫做:异步编程模型。其实就是:多线程并发(效率较高。)
异步就是并发。
同步编程模型:
线程t1和线程t2,在线程t执行的时候,必须等待t2线程执行结束,或者说在t2线程执行的时候,必须等待t1线程执行结束,两个线程之间发生了等待关系,这就是同步编程模型。效率较低。线程排队执行。
同步就是排队。

Java中有三大变量?【重要的内容。】
实例变量:在堆中。
静态变量:在方法区。
局部变量:在栈中。
以上三大变量中:
局部变量永远都不会存在线程安全问题。
因为局部变量不共享。(一个线程一个栈。)
局部变量在栈中。所以局部变量永远都不会共享。
实例变量在堆中,堆只有1个,
静态变量在方法区中,方法区只有1个。
堆和方法区都是多线程共享的,所以可能存在线程安全问题。
局部变量+常量:不会有线程安全问题。
成员变量:可能会有线程安全问题。

如果使用局部变量的话:
建议使用:StringBuilder.
因为局部变量不存在线程安全问题。选择stringBuildere stringBuffer效率比较低。
ArrayList是非线程安全的。 Vector是线程安全的。
HashMap Hashset是非线程安全的。 Hashtable是线程安全的。

总结:
synchronized有三种写法:
第一种:同步代码块。 灵活
synchronized(线程共享对象){
 
	同步代码块;
}
第二种:在实例方法上使用synchronized
表示共享对象一定是this
并且同步代码块是整个方法体。

第三种:在静态方法上使用synchronized
表示找类锁。
类锁永远只有1把。
就算创建了100个对象,那类锁也只有一把,所以这个类new出来的对象都要排队
对象锁:1个对象1把锁,100个对象100把锁。类锁:100个对象,也可能只是1把类锁。

聊一聊,我们以后开发中应该怎么解决线程安全问题?
是一上来就选择线程同步吗?synchronized
不是,synchronized会让程序的执行效率降低,用户体验不好。系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择线程同步机制。
第一种方案:尽量使用局部变量代替"实例变量和静态变量"。
第二种方案:如果必须是实例变量,那么可以考虑创建多个对象,这样
实例变量的内存就不共享了。(一个线程对应1个对象,100个线程对应100个对象,对象不共享,就没有数据安全问题了。)
第三种方案:如果不能使用局部变量,对象也不能创建多个,这个时候就只能选择synchronized了。线程同步机制。

同步代码块synchronized

线程同步机制的语法是:
synchronized(){
 
	// 线程同步代码块。
}
synchronized后面小括号中传的这个“数据”是相当关键的。这个数据必须是多线程共享的数据。才能达到多线程排队。
()中写什么?
那要看你想让哪些线程同步。
假设t1、t2、t3、t4、t5,有5个线程,
你只希望t1t2t3排队,t4t5不需要排队。怎么办?你一定要在()中写一个t1t2t3共享的对象。而这个对象对于t4t5来说不是共享的

在java语言中,任何一个对象都有"一把锁”,其实这把便就是标记。(只是把它叫做锁。100个对象,100把锁。1个对象1把锁。
以下代码的执行原理?
1、假设t1和t2线程并发,开始执行代码的时候,肯定有一个先一个后。
2、线设t1先执行了,遇到了synchronized,这个时候自动找“后面共享对亲”的对象锁,找到之后,并占有这把锁,然后执行同步代码块中的程序,在程序执行过程中一直都是占有这把锁的。直到同步代码块代码结束,这把锁才会释放。
3、假设t1已经占有这把锁,此时t2也遇到synchronized关键字,也会去占有后同共享对象的这把锁,结果这把锁被t1占有,t2只能在同步代码块外面等待的结束,直到t1把同步代码快执行结束了,t1会归还这把锁,此时t2终于等到这把锁,然后 t2占有这把锁之后,进入同步代码块执行程序。
这样就达到了线程排队执行。
这里需要注意的是,这个共享对象一定要选好了。这个共享对象一定是你需要排队执行的这些线程对象所共享的

实例方法上和静态方法上使用synchronized

在实例方法上可以使用synchronized吗?可以的。
synchronized出现在实例方法上,一定锁的是this没得挑。只能是this。不能是其他的对象了。所以这种方式不灵活。
另外还有一个缺点:synchronized出现在实例方法上,表示整个方法体都需要同步,可能会无故扩大同步的
范围,导致程序的执行效率降低。所以这种方式不常用。

synchronized使用在实例方法上有什么优点?
代码写的少了。节俭了。
如果共享的对象就是this,并且需要同步的代码块是整个方法体建议使用这种方式。

synchronized出现在静态方法上是找类锁,因为静态方法是类锁,不管创建几个对象类锁只有一把。

死锁代码要会写,一般面试官要求你会写,只有会写的,才会在以后的开发中注意这个事,因为死锁很难调试

实例

public class 死锁 {
 
    public static void main(String[] args) {
 
        Object a = new Object();
        Object b = new Object();

        //t1 和t2两个线程共享a,b
        Thread t1 = new aa1(a,b);
        Thread t2 = new aa2(a,b);
        t1.start();
        t2.start();
    }
}
class aa1 extends Thread{
 
    Object o1;
    Object o2;
    public aa1(Object o1,Object o2){
 
        this.o1 = o1;
        this.o2 = o2 ;
    }
    //t1执行时占o1锁,t2执行时占o2锁;
    // t1执行完o1,要执行o1里面的o2,但是o2已经被t2占了;
    // t2执行完o2,要执行o2里面的o1,但是o1已经被t1占了;
    //这就屎机了
    //所以尽量少循环嵌套
    public void run() {
 
        synchronized (o1){
  //o1嵌套o2
            try {
 
                sleep(1000);
            } catch (InterruptedException e) {
 
                e.printStackTrace();
            }
            synchronized (o2){
 
            }
        }
    }
}
class aa2 extends Thread{
 
    Object o1;
    Object o2;
    public aa2(Object o1,Object o2){
 
        this.o1 = o1;
        this.o2 = o2 ;
    }
    @Override
    public void run() {
 
        synchronized (o2){
  //o2嵌套o1
            try {
 
                sleep(1000);
            } catch (InterruptedException e) {
 
                e.printStackTrace();
            }
            synchronized (o1){
 
            }
        }
    }
}

守护线程

守护线程
java语言中线程分为两大类:
一类是:用户线程
一类是:守护线程(后台线程)
其中具有代表性的就是:垃圾回收线程(守护线程)。

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

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

实例

/*
所有的用户线程结束,守护线程自动结束
守护守护的意思是:用户线程在,你有必要守护。用户线程没了,你就没必要守护了。
 */
public class 线程守护 {
 
    public static void main(String[] args) {
 
        Thread t = new mm();

        //启动线程前,将线程设置为守护线程
        t.setDaemon(true);

        t.start();

        //主线程  :主线程是用户线程
        for (int i = 0; i < 10; i++) {
 
            System.out.println(Thread.currentThread().getName() +"-->"+i);
            try {
 
                Thread.sleep(1000);
            } catch (InterruptedException e) {
 
                e.printStackTrace();
            }
        }

    }
}
class mm extends Thread{
 
    @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();
            }
        }
    }
}

定时器的作用:
间隔特定的时间,执行特定的程序。
每周要进行银行账户的总账操作,每天要进行数据的备份操作…。

在实际的开发中,每隔多久执行一段特定的程序,这种需求是很常见的,那么在java中其实可以采用多种方式实现:
可以使用sleep方法,睡眠,设置睡眠时间,每到这个时间点醒来,执行任务。这种方式是最原始的定时器。(比较low)
在java的类库中已经写好了一个定时器:java.util.Timer,可以直接拿来用。不过,这种方式在目前的开发中也很少用,因为现在有很多高级框架都是支持定时任务的。在实际的开发中,目前使用较多的是Spring框架中提供的SpringTask框架,这个框架只要进行简单的配置,就可以完成定时器的任务。

实例

/*
使用定时器指定任务
 */
public class 定时器 {
 
    public static void main(String[] args) throws Exception {
 
        // 创建定时器对象
        Timer timer = new Timer();

        //Timer timer = new Timer(true); 守护线程方式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date parse = sdf.parse("2022-9-19 11:52:30");
        //timer.schedule(定时任务,第一次执行时间,间隔多久执行一次);
        timer.schedule(new LogTimerTask(),parse,1000*5); //也可以使用匿名内部类,直接new抽象类

    }
}
class LogTimerTask extends TimerTask{
  //子类继承抽象类,要重写抽象方法

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

生产者和消费者模式

wait和notify方法

关于object类中的wait和notify方法。(生产者和消费者模式!)
第一:wait和notify方法不是线程对象的方法,是java中任何一个java对象都有的方法,因为这两个方式是Object类中自带的。
wait方法和notify方法不是通过线程对象调用,
不是这样的:t.wait(),也不是这样的:t.notify()…不对。
第二:wait()方法作用?
Objecto=newobject(); o.wait();表示:
让正在o对象上活动的线程进入等待状态,无期限等待,直到被唤醒为止。
o.wait();方法的调用,会让"当前线程(正在o对象上活动的线程)“进入等待状态。
第三:notify()方法作用?
Objecto-newbject(); o.notify();表示:
唤醒正在o对象上等待的线程。
还有一个notifyAll方法:
这个方法是唤醒o对象上处于等待的所有线程。

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

什么是“生产者和消费者模式”?
生产线程负责生产,消费线程负责消费。生产线程和消费线程要达到均衡。
这是一种特殊的业务需求,在这种特殊的情况下需要使用wait方法和notify方法。

Linux下Catapro酶动力学预测工具保姆级安装指南(PyTorch+CUDA11.8适配版) 本文提供了Linux系统下Catapro酶动力学预测工具的详细安装指南,特别适配PyTorch+CUDA11.8环境。从环境准备、源码获取到虚拟环境创建、依赖包安装和模型配置,逐步指导用户完成安装流程,并包含常见问题排查和性能优化建议,帮助研究者快速部署这一高效酶动力学参数预测工具。 阅读详情

相关推荐

2025年春科研论文写作指导(如何写好科研论文)研究生网课期末考试

希望能帮助到大家

beijieweiyu的博客 5812

基础知识:浅谈java多线程

WAITING:表示线程处于无限制等待状态,等待一个特殊的事件来重新唤醒,如通过wait()方法进行等待的线程等待一个 notify()或者 notifyAll()方法,通过 join()方法进行等待的线程等待目标线程运行结束而唤醒,一旦通过相关事件唤醒线程,线程就进入了 RUNNABLE 状态继续运行。如果只是调用 run()方法,那么代码还是同步执行的,必须等待一个线程的 run()方法里面的代码全部执行完毕之后,另外一个线程才可以执行其 run()方法里面的代码。

Hugo的博客 726

ICESat-2数据下载及处理分析随笔

ICESat-2全称是Ice,Cloud and land Elevation Satellite -2。看名字我们能知道它的任务是测ice,cloud和land elevation,而且这是一个Satellite,是一颗卫星。那么这里我们就要分清ICESat-2和ATLAS的关系,ICESat-2是星载平台,是一个space observatory,ATLAS是这个星载平台上搭载的单光子激光雷达系统。

u011322358的博客 1万+

Java线程:创建多少线程才是合适的?

Java多线程实战,创建多少线程才是合适的?

ChinaLiaoTian的博客 4733

Windows 11登录界面密码框消失Bug解析与解决方案

Windows操作系统登录认证机制是系统安全的第一道防线,其图形界面由桌面窗口管理器(DWM)负责渲染。当UI元素渲染异常时,会导致密码输入框等关键组件不可见。这类图形子系统故障通常源于驱动兼容性或主题服务冲突,在Windows 11最新累积更新后尤为常见。通过系统文件检查(sfc)、注册表修复或创建新用户等工程实践方法可有效解决问题。对于企业IT环境,建议采用PIN码或生物识别等替代认证方案,同时定期执行磁盘清理和系统健康检查等Windows维护操作,确保认证服务稳定运行。

weixin_33806859的博客 628

微信小程序 - 实现身份证OCR识别人像面与国徽面并提取字段信息,详解从手机相册选取或打开摄像头拍照上传身份证正反面图片ocr文字识别数据填充表单(提供免费纯前端ocr识别插件+百度OCR识别API)

微信小程序身份证识别,微信小程序身份证拍照、上传并OCR识别,微信小程序实现OCR扫描识别,微信小程序识别身份证免费插件,微信小程序实现身份证识别功能。ocr识别插件。微信身份证拍照后进行ocr识别,微信小程序OCR扫描识别身份证,OCR身份证实名认证+图片上传+拍照上传图片,微信小程序之身份证照片正反上传,小程序OCR身份证识别,微信小程序实现文字识别-ocr插件,微信小程序利用百度AI实现扫描身份证获取信息功能,基于微信小程序OCR插件实现身份证拍照、上传并OCR识别的示例demo,将上传的照片传到服务

🏆 前端领域优质创作者 8141

【Java】为什么使用多线程?

使用多线程的理由之一是和进程相比,它是一种非常花销小,切换快,更"节俭"的多任务操作方式。在Linux系统下,启动一个新的进程必须分配给它独立的地址空间,建立众多的数据表来维护它的代码段、堆栈段和数据段,这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程,它们彼此之间使用相同的地址空间,共享大部分数据,启动一个线程所花费的空间远远小于启动一个进程所花费的空间,而且,线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。使用多线程的理由之二是线程间方便的通信机制。

微信公众号: 后端码匠 4115

Python 爬虫实战:共享单车数据采集全流程与市场洞察深度剖析

本文介绍了如何利用Python爬虫技术获取和分析共享单车运营数据。文章从项目背景出发,详细阐述了系统架构设计,包括数据抓取、清洗存储、分析和可视化模块。通过Scrapy、BeautifulSoup等工具实现数据采集,使用Pandas进行数据清洗,并借助Matplotlib进行可视化分析。实战部分展示了爬虫代码示例和城市分布、使用频率等分析案例。最终指出数据驱动分析有助于了解行业现状和市场趋势,未来可结合机器学习等方法进行深入洞察。该技术方案为共享单车行业研究提供了有效的数据支持。

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 2236

看一眼就会Java多线程!(如何全面理解多线程)

Java多线程技术解析,线程是什么?线程的优缺点?如何创建多线程?开发优先选择那种方式创建线程?

qq_51070724的博客 1484

05 - GRACE数据处理-球谐展开与球谐综合

GRACE数据处理-球谐展开和综合前面在介绍GRACE相关理论的时候提到过下面的公式,从公式形式上可以看出,面密度变化和球谐系数(CS)之间是能够相互转换的,那这个转化的过程可以称为球谐展开,简单理解就是将全球网格数据转化为球谐系数的过程。而球谐综合可以看作是球谐展开的逆过程,利用球谐系数计算到全球格网分布。

weixin_43339605的博客 1050

RedCap:一种通信技术的概述

总结起来,RedCap是一种基于数据包交换的通信技术,它提供了一种高效、可靠的数据传输机制。通过使用RedCap,我们可以轻松地发送和接收数据包,并确保数据的完整性和正确性。在上面的示例中,我们首先导入了RedCap库,并创建了一个RedCap实例。然后,我们定义了目标地址和源地址,并创建了一个数据包,其中包含了目标地址、源地址和要发送的数据。本文将介绍RedCap的基本原理和使用方法,并提供一些相关的源代码示例。RedCap还提供了其他一些功能,如数据包的重传机制、流量控制和拥塞控制等。

YgjWeb的博客 900

两万字带你搞透Java多线程

深度讲解Java多线程并发

一个程序员的自我救赎。 1156

【语音分析】语音倒谱分析(变声器 男变女 女变男 童声)【含GUI Matlab源码 4247期】

语音倒谱分析(变声器 男变女 女变男 童声) 完整的代码,方可运行;可提供运行操作视频!适合小白!

订阅付费专栏Matlab(奶茶价版),可赠送奶茶价版付费专栏指定代码1份; 826

[Java进阶] Swing两万字大总结一(超详细教程,这不得收藏一波)

Swing 组件通常被称为 “轻量级组件”,因为它完全由 Java 语言编写,Java 是不依赖于操作系统的语言,它可以在任何平台上运行,而依赖于本地平台的组件相应地被称为 “重量级组件”,比如 AWT 组件就是依赖本地平台的窗口系统来决定组件的功能、外观和风格的。.........

一以贯之的努力 不得懈怠的人生 7万+

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

万字图解Java多线程

前言 java多线程我个人觉得是javaSe中最难的一部分,我以前也是感觉学会了,但是真正有多线程的需求却不知道怎么下手,实际上还是对多线程这块知识了解不深刻,不知道多线程api的应用场景,不知道多线程的运行流程等等,本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长,大家也可以有选择的看具体章节,建议多线程的代码全部手敲,永远不要相信你看到的结论,自己编码后运行出来的,才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行,就开启了一个进程, 比如启动了qq,w.

qq_35598736的博客 6万+

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

两万字带你掌握多线程

文章从多线程的进程和线程讲起,从头到尾讲解了多线程的掌握,通过类,创建线程,中断线程,线程休眠,线程状态,synchronized 的使用,来掌握多线程

sjp151的博客 392

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

两万字解析java

两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解析java两万字解

2505_90340337的博客 597

[Java进阶] Swing两万字大总结二

面板、布局管理器和事件监听器

一以贯之的努力 不得懈怠的人生 3656

Java8—Stream流式编程、Optional容器的详细介绍【两万字】

基于Java8详细介绍了Stream流的含义和大部分API方法的使用,以及Optional容器、并行流等Java8的新特性!

终生学习践行者 4658

Java多线程基础——两万字详解

Java多线程基础——两万字详解

如风暖阳的博客 908

【Java】带你从零详细理解多线程

本文从0介绍了什么是多线程,包括创建多线程对象,熟悉成员方法,包含线程的安全问题,lock锁死锁等,等待唤醒机制,阻塞队列,线程池,自定义线程池的七个参数,真正了解多线程

Answer的博客 2802

三万字总结Java多线程

JUC简介 在Java中,线程部分是一个重点,本篇文章说的JUC也是关于线程的。JUC就是java.util.concurrent工具包的简称。这是一个处理线程的工具包,JDK1.5开始出现的。 线程与进程 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象。 进程(process)是程序的一次执行过程,或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。---生命周期 进程 — 资源分配的最小单位。 线程(th..

weixin_49329785的博客 5388

一文带你了解Java多线程

Java多线程是Java语言的核心特性,允许程序同时执行多个任务,提高程序执行效率并充分利用多核CPU资源。本文系统介绍了Java多线程的架构、核心概念和实现方式,包括线程创建(继承Thread类、实现Runnable接口、Callable接口)、同步机制(synchronized、ReentrantLock、volatile)和线程通信(wait/notify、CountDownLatch、CyclicBarrier)。文章还分析了JDK源码中的Thread类实现,并总结了多线程的优势(提高性能、响应性、

new_daimond的博客 1033

Java EasyExcel带格式多线程导出百万数据

Java结合Alibaba EasyExcel,通过多线程加redis缓存的方式,将明细表数据带有数据格式(字体格式,表头冻结,单元格合并等格式),导出百万数据量,响应时间30s左右。

入门程序猿的博客 9758

Java多线程(详细了解java多线程机制)

每天进步一点点一、程序、进程、线程1.1 什么是程序1.2 什么是进程1.3 什么是线程1.4 进程和线程的区别二、创建线程的三种方式2.1 继承Thread类重写run()方法具体实现获取线程ID和名称修改线程名称2.2 实现Runnable接口实现run()方法具体实现使用匿名内部类2.3 实现Callable接口Callable和Thread、Runnable比较具体实现三、线程的状态3.1 基本四状态3.2 等待状态3.3 阻塞状态四、线程常用的方法4.1 线程休眠(sleep)4.2 线程放弃

来了点个赞再走... 4128

Java小白教学—五千字带你了解多线程机制及线程安全问题

七大核心问题带你突破线程问题!内容超详细~适合小白学习,巩固复习。

小谷同学的博客 1267
上一篇: SpringBoot2源码1-嵌入式Tomcat启动和@SpringBootApplication注解原理
下一篇: Linux多线程
java_lujj
博客等级 码龄4年 18粉丝 152原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值