一、多线程
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对象上处于等待的所有线程。