大家都知道,像我们平常观看直播的弹幕是怎样实现的吗? 通过多线程实现的群发弹幕
什么是线程呢?
线程(thread)是一个程序内部的一条执行路径。程序中如果只有一条执行路径,那么这个程序就是单线程的程序。
就例如:我们之前启动程序执行后,main方法的执行其实就是一条单独的执行路径。
多线程什么呢?
多线程是指从软硬件上实现多条执行流程的技术。
多线程用在哪里,有什么好处?
消息通信、淘宝、京东系统都离不开多线程技术。
多线程是这么实现的呢?
我总结了三种Java实现多线程的方案:
一、多线程的实现方案一:继承Thread类
1、定义一个子类MyThread继承线程类java.lang.Thread,并重写run()方法
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行了:"+i);
}
}
}
2、创建 MyThread类的对象
//3、new一个新线程对象 Thread t = new MyThread();
3、调用线程对象的start()方法启动线程(启动以后还是会执行run方法的)
//4、调用start方法启动线程(执行的还是run方法) t.start();
4、完整代码
a.主类
//主类
public class ThreadDemo1 {
public static void main(String[] args) {
//3、new一个新线程对象
Thread t = new MyThread();
//4、调用start方法启动线程(执行的还是run方法)
t.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行了:"+i);
}
}
}
b.子类
//子类
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行了:"+i);
}
}
}
优缺点:
优点:编码简单
缺点:线程已经继承了Thread,无法继承其他类了,不利于扩展。
注意:
为什么不直接调用了run方法,而是调用start启动线程。
直接调用run方法会当成普通方法执行,此时相当于还是单线程执行。 只有调用start方法才是启动一个新的线程执行。
一定不要把主线程任务放在子线程之前了。
因为这样会使主线程一直是先跑完的,相当于是一个单线程的效果了。
二、多线程的实现方案二:实现Runnable接口
1、定义一个线程任务类MyRunnable实现Runnable接口,重写run()方法
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程执行了:"+i);
}
}
}
2、创建MyRunnable任务对象
//3、创建一个任务对象 Runnable target = new MyRunnable();
3、把MyRunnable任务对象交给Thread处理。
//4、把任务对象交给Thread处理 Thread t = new Thread(target);
4、调用线程对象的start()方法启动线程
//5、启动线程 t.start();
5、完整代码
a.主类
//主类
public class ThreadDemo2 {
public static void main(String[] args) {
//3、创建一个任务对象
Runnable target = new MyRunnable();
//4、把任务对象交给Thread处理
Thread t = new Thread(target);
//5、启动线程
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("主线程执行了:"+i);
}
}
}
b.子类
//子类
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程执行了:"+i);
}
}
}
另一种多线程的实现方案二:匿名内部类方式实现
1、可以创建Runnable的匿名内部类对象。
//1、创建一个任务对象
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线1程执行了:" + i);
}
}
};
2、交给Thread处理。
//2、把任务对象交给Thread处理 Thread t = new Thread(target);
3、调用线程对象的start()启动线程。
//3、启动线程 t.start();
4、完整代码
public class ThreadDemo2Other {
public static void main(String[] args) {
//1、创建一个任务对象
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线1程执行了:" + i);
}
}
};
//2、把任务对象交给Thread处理
Thread t = new Thread(target);
//3、启动线程
t.start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线2程执行了:" + i);
}
}
}).start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
System.out.println("子线3程执行了:" + i);
}
}).start();
for (int i = 0; i < 10; i++) {
System.out.println("主线程执行了:"+i);
}
}
}
优缺点:
优点:线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强。
缺点:编程多一层对象包装,如果线程有执行结果是不可以直接返回的。
三、多线程的实现方案三:JDK 5.0新增:实现Callable接口
1、得到任务对象
a.定义类实现Callable接口,重写call方法,封装要做的事情。
class MyCallable implements Callable{ private int n; public MyCallable(int n) { this.n = n; } @Override public String call() throws Exception { int sum = 0; for (int i = 1; i <= n; i++) { sum += i; } return "子线程的执行结果是:"+sum; } }
b.用FutureTask把Callable对象封装成线程任务对象。
//3、创建Callable任务对象
Callable call = new MyCallable(100);
//4、把Callable任务对象 交给FutureTask 对象
//FutureTask对象的作用1:是Runnable的对象(实现了Runnable接口),可以交给Thread了
//FutureTask对象的作用2:可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
FutureTask f1 = new FutureTask<>(call);
2、把线程任务对象交给Thread处理。
//5、交给线程处理 Thread t1 = new Thread(f1);
3、调用Thread的start方法启动线程,执行任务
//6、启动线程 t1.start();
4、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。
//7、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。
try {
String s1 = f1.get();
System.out.println("第一个结果"+s1);
} catch (Exception e) {
e.printStackTrace();
}
5、这样你看到的其实是一个单线程的任务,如果要实现多线程你可以在创建一个Callable任务对象。如上,继续往下执行就可以了。这里我实现了一个求和的函数,比较简单。如果有要实现难的 函数照样,重写call方法在里面写上你所要执行的函数就OK了。
优缺点:
优点:线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强。
可以在线程执行完毕后去获取线程执行的结果。
缺点:编码复杂一点。



