什么是线程?
线程(Thread)是一个程序内部的一条执行流程
程序中如果只有一条执行流程,那这个程序就是单线程程序。
什么是多线程?
多线程是指从软硬件上实现的多条执行流程的技术(多条线程由CPU负责调度执行)。
如何在程序中创建出多条线程?
Java是通过java.lang.thread包来创造线程的。
class PrimeThread extends Thread{
long minPrime;
PrimeThread(long minPrime)
{
this.minPrime = minPrime;
}
public void run()
{
//continue primes larger than
}
}
示例如下
public class ThreadTest1 {
public static void main(String[] args) {
//3、创建MyThread线程类的对象代表一个线程
Thread t = new Thread();
//4、启动线程(自动执行run方法)
t.start();
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}
// 1、让子类继承Thread 线程类
public class MyThread extends Thread{
//2、必须重写Thread类的run方法
@Override
public void run()
{
//描述线程的执行任务。
for(int i=1;i<=10;i++)
{
System.out.println(i);
}
}
}
多线程的创建方式一:继承Thread类
定义一个子类MyThread继承线程类java.lang.Thread,重写run()
创建MyThread类的对象
调用线程对象的start()方法启动线程(启动后还是执行run方法)
方式一优缺点:
优点:编程简单
缺点:线程类已经继承Thread,无法继承其他类,不利于功能扩展
多线程注意事项
1、启动线程必须是调用start方法,不是调用run方法
直接调用run方法会当成普通方法执行,此时相当于还是单线程执行。
只有调用start方法才是启动一个新的线程执行
2、不要把主线程任务放在启动子线程之前
这样主线程一直是先跑完的,相当于是一个单线程的效果了。
多线程的创建方式二:实现Runnable接口
定义一个线程任务类MyRunnable实现Runnable接口,重写run()方法
创建MyRunnable任务对象
把MyRunnable任务对象交给Thread处理
Thread类提供的构造器 | 说明 |
---|---|
public Thread(Runnable target) | 封装Runnable对象成为线程对象 |
方式二的优缺点
优点:任务类只是实现接口,可以继续继承其他类、实现其他接口、扩展性强。
public class ThreadTest2 {
public static void main(String[] args) {
//3、创建任务对象
Runnable target = new MyRunnable();
//4、把任务交给一个线程对象去处理
//public Thread (Runnable target)
new Thread(target).start();
for (int i = 0; i < 10; i++) {
System.out.println( "主线程输出" + i);
}
}
}
public class MyRunnable implements Runnable {
public void run() {
//线程执行的任务
for (int i = 0; i < 10; i++) {
System.out.println("子线程输出"+i);
}
}
}
线程创建方式二的匿名内部类写法
1、可以创建Runnable的匿名内部类对象
2、再交给Thread线程对象
3、再调用线程对象的start()启动线程
public class Threadtest3 {
public static void main(String[] args) {
//1、直接创建Runnable接口的匿名内部类形势
Runnable target = new Runnable() {
@Override
public void run(){
for (int i = 0; i < 10; i++) {
System.out.println("子线程输出"+i);
}
}
};
new Thread(target).start();
//简化形势
new Thread(new Runnable(){
@Override
public void run(){
for (int i = 0; i < 10; i++) {
System.out.println("子线程2输出"+i);
}
}
}).start();
for (int i = 0; i < 10; i++) {
System.out.println("主线程main输出"+i);
}
}
}
多线程的第三种创建方式:利用Callable接口、FutureTask类来实现。
1、创建任务对象
定义一个类实现Callable接口,重写call方法,封装要做的事情,和返回的数据。
把Callable类型对象封装成FutureTask(线程任务对象)。
2、把线程任务对象交给Thread对象
3、调用Thread对象的start方法启动线程
4、线程执行完毕后、通过FutureTask(线程任务对象)
//1、让这个类实现Callable接口
public class MyCallable implements Callable<String>{
private int n;
public MyCallable(int n)
{
this.n =n;
}
//2、重写call方法
@Override
public String call() throws Exception{
//描述线程的任务,返回线程执行返回后的结果
//需求:求1-n的和返回。
for(int i=1;i<n;i++)
{
sum+=i;
}
return "线程求出1-"+n+"的和是"+sum;
}
}
import java.sql.SQLOutput;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class ThreadTest2 {
public static void main(String[] args) throws Exception {
//3、创建一个Callable的对象
Callable<String> callable = new MyCallable(100);
//4、把Callable的对象封装成一个FutureTask对象(任务对象)
//未来任务对象的作用?
//1、是一个任务对象,实现了Runnable对象
//2、可以在线程执行完毕之后,和未来任务对象调用get方法获取线程执行完毕后
FutureTask<String> f1 = new FutureTask<>(callable);
//5、把任务对象交给一个Thread对象
new Thread(f1).start();
Callable<String> call2 = new MyCallable(100);
FutureTask<String> f2 =new FutureTask<>(call2);
new Thread(f2).start();
//6、获取线程执行完毕后返回的结果
//注意:如果执行到这,假如上面的线程还没有执行完毕
//这里的代码会暂停,等待上面线程执行完毕后才会返回
String rs=f1.get();
System.out.println(rs);
String rs2 = f2.ge