由该视频整理得：视频链接
进程和线程
- 进程A和进程B的内存独立不共享。
- 在java中同一进程不同线程间的堆区（new出来的对象）和方法区（代码、静态变量等）的资源共享，栈区资源不共享。
- 并不是一个方法对应一个线程。
多线程的实现
- 类继承Thread类并重写run方法。
public class Test {
public static void main(String[] args) {
// 这里是main方法，在主线程中执行
// 新建一个分支线程对象
MyThread myThread = new MyThread();
// 启动线程
// 该方法的作用是启动一个分支线程，在JVM中开启一个新的栈空间
// 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部
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);
}
}
}
- 编写的类实现Runable接口，并将其对象作为参数传递给Thread的构造方法。建议使用该方式，实现接口以后该类还可以继承其他类。
public class Test {
public static void main(String[] args) {
// 创建一个实现了Runnbale接口的类
MyRunable r = new MyRunable();
// 将可运行的对象封装成一个线程对象
Thread t = new Thread(r);
// 启动线程
t.start();
for (int i = 0; i < 1000; i++) {
System.out.println("主线程-->" + i);
}
}
}
// 这并不是一个线程类，只是一个runnable的类
class MyRunable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("分支线程-->" + i);
}
}
}
- 采用匿名内部类的方式实现Runnable接口
public static void main(String[] args) {
// 匿名内部类的实现
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);
}
}
- 实现Callable接口（JDK8新特性）
系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，使用该种方式可以获取该执行结果。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test {
public static void main(String[] args) {
// 第一步:创建一个“未来任务类”对象。
// 参数非常重要，需要给一个caLLable接口实现类对象。
FutureTask task = new FutureTask(new Callable() {
// 该call方法相当于Runable接口中的run方法
@Override
public Object call() throws Exception {
return null;
}
});
// 创建线程对象
Thread t = new Thread(task);
// 启动线程
t.start();
// 如何在主线程获取t线程的返回结果
// get方法的执行会导致当前线程阻塞（必须等t线程运行结束才能获取返回值）
try {
Object obj = task.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
多线程的常用方法
public final String getName() //获取名字（自定义线程的默认名字为Thread -数字）
public final synchronized void setName() //设置线程名字
public static native Thread currentThread() //获取当前正在运行的线程，我们通常将currentThread和getName结合使用来获得当前正在运行的线程的name
public static native void sleep(long millis) throws InterruptedException //让当前线程进入阻塞状态（该代码出现在哪个线程，让哪个线程阻塞）
public void interrupt() //中断线程的睡眠状态（依靠java的异常处理机制实现）
public final void stop() //结束线程（不建议使用，容易丢失数据）
public final void setPriority(int newPriority) //设置线程优先级（默认优先级5，最低优先级1，最高优先级100）
public static native void yield() //让当前正在执行的线程进入就绪状态，让位给其他线程执行（不是阻塞）
如何结束线程
我们通过在自定义类中设置一个标志，通过修改标志来结束线程
public class Test {
public static void main(String[] args) {
// 这里是main方法，在主线程中执行
// 新建一个分支线程对象
MyThread myThread = new MyThread();
// 启动线程
// 该方法的作用是启动一个分支线程，在JVM中开启一个新的栈空间
// 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部
myThread.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
myThread.setRun(false);
System.out.println("程序运行结束");
}
}
class MyThread extends Thread {
// 我们通过在自定义类中设置一个标志，通过修改标志来结束线程
private boolean run = true;
@Override
public void run() {
// 编写程序，这段程序运行在分支线程中
for (int i = 0; i < 1000; i++) {
if (run) {
System.out.println("分支线程-->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
//可以在这里将需要保存的数据保存
return;
}
}
}
public void setRun(boolean run) {
this.run = run;
}
}
syncrosized
- 同步代码块
synchronized (线程共享对象){
同步代码块;
}
//()中写什么?那要看你想让哪些线程同步。
//假设t1、t2、t3、t4、t5，有5个线程，你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办?你一定要在()中写一个t1 t2 t3共享的对象，而这个对象对于t4 t5来说不是共享的。
-
在实例方法上使用synchronized
表示共享对象一定是this，并且同步代码块是整个方法体 -
在静态方法上使用synchronized
类锁用于保护静态变量的安全
就算创建了100个对象,那类锁也只有一把。
对象锁:1个对象1把锁,100个对象100把锁
类锁:100个对象,也可能只是1把类锁 -
局部变量永远都不会存在线程安全问题。
实例变量在维中，静态变量在方法区中。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。 -
synchronized代码块范围越大，效率越低。
应该怎么解决线程安全问题
- 尽量使用局部变量代替"实例变量和静态变量”。
- 如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。(一个线程对应1个对象，100个线程对应100个对象，对象不共享,就没有数据安全问题了。）
- 如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。
守护线程
- java语言中线程分为用户线程和守护线程。守护线程中具有代表性的就是:垃圾回收线程。
- 守护线程的特点:
一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。 - 主线程main方法是一个用户线程。
- 守护线程用在什么地方呢?
比如，每天00:00的时候系统数据自动备份。这个需要使用到定时器，并且我们可以将定时器设置为守护线程。一直在那里看着，每到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。 - 如何设置守护线程？
public final void setDaemon(boolean on)
定时器
在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，那么在java中其实可以采用多种方式实现:
- 可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。(比较low)
- 在java的类库中已经写好了一个定时器:java.util.Timer，可以直接拿来用不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
- 在实际的开发中，目前使用较多的是Spring框架中提供的springTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。
- 使用Timer实现定时器，继承TimerTask类，并调用Timer类的schedule方法即可。
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class Test {
public static void main(String[] args) {
Timer timer = new Timer();
// 定时任务，开始时间，间隔时间
timer.schedule(new LogTimerTask(), new Date(), 1000);
}
}
// 编写一个类继承TimerTask即可
class LogTimerTask extends TimerTask {
@Override
public void run() {
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = sdf.format(date);
System.out.println(s + "时刻执行了一次");
}
}
扫一扫
8682
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
