Java教程
多线程
Java中的三大变量:
实例变量：在堆中
静态变量：在方法区中
局部变量：在栈中
以上三大变量中：
局部变量永远都不会存在线程安全问题
因为局部变量不共享（一个线程一个栈）
局部变量在栈中，所以局部变量永远都不会共享
实例变量在堆中，堆只有一个
静态变量在方法区中，方法区只有一个
堆和方法区都是多线程共享的，所以可能存在线程安全问题
synchronized三种写法：
第一种：同步代码块
synchronized(线程共享对象){
同步代码块
}
第二种：在实例方法上使用synchronized
表示共享对象一定是this
并且同步代码块是整个方法体
第三种：在静态方法上使用synchronized
表示找类所
类所永远只有一把
就算创建了一百个对象，类锁也只有一把
以后在开发中应该怎么解决线程安全问题
使用synchronized会让程序执行效率降低，用户体验不好
系统的用户吞吐量降低，用户体验差，不得已的情况下再使用
线程同步机制
第一种方案：尽量使用局部变量代替“实例变量和静态变量”
第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样
实例变量的内存就不共享了，（一个线程对应一个对象，一把个线程对应一百个对象，
对象不共享，就没有数据安全问题了）
第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能
选择synchronized了，线程同步机制
守护线程
java语言中线程分为两大类：
一类是:用户线程
一类是：守护线程（后台线程）
其中具有代表性的就是：垃圾回收线程（守护线程）
守护线程的特点：
一般守护线程是一个死循环，所有的用户线程只要结束。
守护线程自动结束
注意：主线程main是一个用户线程
守护线程用在什么地方呢？
每天00:00的时候系统数据自动备份
这个需要使用到定时器，并且我们可以将定时器设置为守护线程
一直在那里看着，每到00:00的时候就备份一次，所以的用户线程
如果结束了，守护线程自动退出，没有必要进行数据备份了
public static void main(String[] args) {
Thread t= new BakDataThread();
t.setName("备份线程-->");
// 启动线程之前，将线程设置为守护线程
t.setDaemon(true);
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("main--->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
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();
}
}
}
}
定时器
定时器的作用：
间隔特定的时间，去执行特定的程序
在实际开发中，每隔多久执行一段特定的程序，这种需求是很常见的，
那么在java中有很多方法可以实现：
可以使用sleep方法，睡眠，设置睡眠时间，每到这个时间点醒来，执行
任务，这种方式是最原始的定时器
在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用
不过这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时
任务的
在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，
这个框架只要进行简单的配置，就可以完成定时器的任务
public static void main(String[] args) {
// 创建定时器对象
Timer timer = new Timer();
// Timer timer1 = new Timer(true);// 守护线程的方式
// 指定定时任务
// timer.schedule();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
Date firstDate = sdf.parse("2021-8-26 14:40:00");
// 匿名内部类
timer.schedule(new TimerTask() {
@Override
public void run() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strDate = sdf.format(new Date());
System.out.println(strDate + "完成了一次数据备份");
}
}, firstDate, 1000 * 10);
} catch (ParseException e) {
e.printStackTrace();
}
}
}
// 编写一个定时任务类
// 假设这是一个记录日志的定时任务
/*
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 + ":完成了一次数据备份");
}
}
*/
实现线程的第三种方式：实现Callable接口（JDK8新特性）
这种方式实现的线程可以获取线程的返回值
前两种无法获取返回值，run返回void
public static void main(String[] args) {
// 第一步：创建一个“未来任务”类对象
FutureTask task = new FutureTask(new Callable() {
@Override
public Object call() throws Exception { // call()方法就相当于run方法，只不过这个有返回值
// 线程执行一个任务，执行之后可能会有一个执行结果
// 模拟执行
System.out.println("call method begin");
Thread.sleep(1000 * 10);
System.out.println("call method end");
int a = 100;
int b = 200;
return a + b; // 自动 装箱（变成Integer）
}
});
// 创建线程对象
Thread t = new Thread(task);
//启动线程
t.start();
// 这里是main()方法，这是在主线程中
// 在主线程中，怎么获取t线程的返回结果呢？
try {
// get()方法的执行会导致当前线程阻塞
Object obj = task.get();
System.out.println("线程执行结果--->" + obj);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
// main方法这里的程序想要执行必须等待get()方法结束
// 而get()方法可能需要执行很久。因为get()方法是为了拿到另一个线程的结果
// 另一个线程执行是需要时间的
System.out.println("hello jack");
}
}
死锁：
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
Thread t1 = new MyThread1(o1,o2);
Thread t2 = new MyThread2(o1,o2);
t1.setName("t1");
t2.setName("t2");
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 void run(){
synchronized(o2){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(o1){
}
}
}
public MyThread2(Object o1, Object o2){
this.o1 = o1;
this.o2 = o2;
}
}
关于Object类中的wait和notify方法（生产者和消费者模式）
第一：wait和notify方法不是线程对象的方法，是java中任何一个Java对象
都有的方法，因为这两个方式是Object类中自带的
wait and notify 方法不是通过线程对象调用的
第二：wait()方法作用？
Object o = new Object();
o.wait();
表示：
让正在o对象上活动的线程进入等待状态，无期限等待，
直到被唤醒为止
o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态
第三：notify()方法作用
Object o = new Object();
o.notify();
表示：
唤醒正在o对象上等待的线程
还有一个notifyAll()方法：
这个方法是唤醒o对象上处于等待的所有线程
package com.cedric.java.thread;
import java.util.ArrayList;
import java.util.List;
/*
1.使用wait()和notify方法实现“生产者和消费者模式”
2.什么是“生产者和消费者模式”？
生产线程负责生产，消费线程负责消费
生产线程和消费线程要达到均衡
这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法、
3.wait方法和notify方法建立在线程同步的基础之上，因为多线程要同时操作一个仓库，有线程安全问题
4.wait方法作用：o.wait()让正在o对象上获取的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁
5.notify方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占用的锁
6.模拟这样一个需求：
仓库采用List集合
List集合中假设 只能存储一个元素
1个元素就表示仓库满了
如果List集合中元素个数是0，就表示仓库空了
保证List集合中永远都是最多存储一个元素
必须做到这种效果：生产一个消费一个
*/
public class ThreadTest15 {
public static void main(String[] args) {
// 创建一个仓库对象，共享的
List list = new ArrayList();
// 创建两个线程对象
// 生产者线程
Thread t1 = new Thread(new Producer(list));
// 消费者线程
Thread t2 = new Thread(new Consumer(list));
t1.setName("生产者线程：");
t2.setName("消费者线程：");
t1.start();
t2.start();
}
}
// 生产线程
class Producer implements Runnable{
// 仓库
private List list;
public Producer(List list) {
this.list = list;
}
@Override
public void run() {
// 一直生产(使用死循环来模拟一直生产)
while(true){
// 给仓库对象list加锁
synchronized(list){
if(list.size() > 0){ // 大于0，说明仓库中已经有一个元素了
try {
// 当前线程进入等待状态，并且释放Producer之前占有的list集合的锁
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 程序能够到这里说明仓库是空的，可以生产
Object obj = new Object();
list.add(obj);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
// 唤醒消费者消费
list.notify();
}
}
}
}
// 消费线程
class Consumer implements Runnable{
// 仓库
private List list;
public Consumer(List list) {
this.list = list;
}
@Override
public void run() {
// 一直消费
while(true){
synchronized (list){
if(list.size() == 0){
try {
// 仓库已经空了
// 消费线程等待，释放掉list集合的锁
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 程序能够执行到此处说明仓库中有数据，进行消费
Object obj = list.remove(0);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
// 唤醒生产者生产
list.notify();
}
}
}
}
-
TiDB 资源管控的对撞测试以及最佳实践架构07-04
-
万字长文聊聊Web3的组成架构07-03
-
springboot项目无法注册到nacos-icode9专业技术文章分享07-02
-
结对编程到底难不难？答案在这里06-26
-
《2023版Java工程师》课程升级公告06-19
-
matplotlib作图不显示3D图，怎么办？06-15
-
03-Loki 日志监控06-15
-
04-让LLM理解知识 -Prompt06-15
-
做软件测试需要懂代码吗？06-05
-
14-ShardingSphere的分布式主键实现06-05
-
为什么以及如何要进行架构设计权衡？06-03
-
全网首发第二弹！软考2024年5月《软件设计师》真题+解析+答案！（11-20题）05-31
-
全网首发！软考2024年5月《软件设计师》真题+解析+答案！（21-30题）05-31
-
【Java】百万数据excel导出功能如何实现05-30
-
我们小公司，哪像华为一样，用得上IPD（集成产品开发）？05-30
