多线程Thread

多线程

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

继承 Thread 类实现多线程

这种方法，一定要重写run() 方法

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

// 如果不用 start() 方法，而是调用 run() 方法，则不会启动线程，不会分配新的分支栈。 (这种方式就是单线程)
thread.run();
for (int i = 0; i < 100; i++) 
   System.out.println("主线程---->"+ i +"");

class MyThread extends Thread {
    @Override
    public void run() {
        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

实现 Runnable 接口实现多线程

重写run() 方法，同样用 start创建分支栈

Thread thread = new Thread(new Runnable() {
   @Override
   public void run() {
      for (int i = 0; i < 100; i++) {
         System.out.println("分支线程---->" + i);
      }
   }
});
thread.start();
for (int i = 0; i < 100; i++) {
   System.out.println("主线程---->" + i);
}
1
2
3
4
5
6
7
8
9
10
11
12

start方法结束，表示该分支线程进入就绪态，在竞争CPU执行权，当run方法的开始执行标志着这个线程进入运行态。当占有的CPU时间片用完之后，会重新回到就绪状态继续抢夺CPU时间片，当再次
抢到之后，就开始执行run方法，

重点:run()当中的异常不能throws，只能try catch因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。

线程常用方法

Mythread t = new MyThread();
String name = t.getName();  // 获取线程名字
t.setName("新");	// 设置线程名字
Thread thread = Thread.currentThread();  // 返回当前正在运行的线程

// 让当前线程进入休眠，进入“阻塞状态”,放弃占有CPU时间片，让给其它线程使用。参数为毫秒
Thread.sleep(1000);	

t.interrupt();  // 叫醒正在睡眠的当前线程
1
2
3
4
5
6
7
8
9

实例方法

1. void setPriority (int newPriority) 设置线程的优先级
2. int getPriority() 获取线程优先级. 最低优先级1 默认优先级是5 最高优先级10
3. void join() 让调用该方法的线程合并到当前线程中，当前线程受阻塞，线程执行到结束再执行当前线程。

静态方法

1. static void yield() 让位方法 暂停当前正在执行的线程对象，并执行其他线程
   yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。yield()方法的执行会让当前线程从"运行状态”回到\就绪状态"。

常用的终止线程方法

MyThread02 myt = new MyThread02();
Thread thread = new Thread(myt);
thread.start();
try {
   Thread.sleep(3000);
} catch (InterruptedException e) {
   e.printStackTrace();
}
// 终止线程
myt.runn = false;
for (int i = 0; i < 100; i++) {
   System.out.println("主线程---->" + i);
}

class MyThread02 implements Runnable {
   boolean runn = true;
   @Override
   public void run() {
      if (runn) {
         for (int i = 0; i < 100; i++) {
            System.out.println("分支线程---->" + i);
         }
      } else {
         // 在这里写保存数据操作
         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

多线程安全

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

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

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

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

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

synchronized

线程同步机制的语法是:

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

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

什么时候数据在多线程并发的环境下会存在安全问题呢? 需要三个条件:

1. 多线程并发 有共享数据 共享数据有修改的行为 满足以上3个条件之后，就会存在线程安全问题。

Java三大变量

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

synchronized三种写法:

1. 同步代码块 灵活
   synchronized (线程共享对象) { 同步代码块; }
2. 在实例方法上使用 synchronized 表示共享对象一定是this，并且同步代码块是整个方法体。
3. 在静态方法上使用 synchronized 表示找类锁。类锁永远只有1把。就算创建了100个对象，那类锁也只有一把。对象锁: 1个对象1把锁，100个 对象100把锁。类锁: 100个对象，也可能只是1把类锁。

我们以后开发中应该怎么解决线程安全问题? 是一上来就选择线程同步吗? synchronized 会让程序的执行效率降低，用户体验不好。系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择线程同步机制。

1. 尽量使用局部变量代替"实例变量和静态变量
2. 如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。(一个线程对应1个对象，100个 线程对应100个对象。对象不共享，就没有数据安全问题了。)
3. 如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制。

守护线程

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

1. 一般守护线程是-一个死循环，所有的用户线程只要结束，守护线程自动结束。哪怕守护线程是死循环的代码，也会结束
2. 主线程main方法是一个用户线程。
3. 语法：实例对象.setDaemon(true) 只需要在start 方法前使用该方法将该线程对象设置为守护线程

定时器

定时器的作用 间隔特定的时间，执行特定的程序
在java中其实可以采用多种方式实现:

1. 使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。(比较low) 不用
2. 在java的类库中已经写好了一个定时器: jalva.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。在实际的开发中，目 前使用较多的是Spring框架中提供的SpringTask框架,这个框架只要进行简单的配置，就可以完成定时器的任务。底层就是用下面的代码实现：

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

// 指定定时任务  timer.schedule(定时任务，啥时候开始执行，间隔多久执行一次)
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
   Date start = format.parse("2022-08-27 16:43:00");
   timer.schedule(new MyTask(), start, 5000);
} catch (ParseException e) {
   e.printStackTrace();
}

class MyTask extends TimerTask {
   @Override
   public void run() {
      System.out.println("系统数据备份完成！");
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

wait与notify

wait 与 notify 方法不是线程类的方法，而是 Object 的方法，任何一个对象都有的

1. o.wait方法会让正在o对象上活动的当前线程进入等待状态,并且释放之前占有的o对象的锁
2. o.notify 方法只会通知,不会释放之前占有的o对象的锁。唤醒正在o对象上等待的线程。
   notifyAll ()方法: 这个方法是唤醒o对象上处于等待的所有线程。