多线程
英语:multithreading,
是指从软件或者硬件上实现多个线程并发执行的技术
重点:
当多个线程跑起来时,没有先后顺序.
线程实现的方式:
四种方法:
方法一:继承·Thread类,重写run方法
不建议使用,无法避免OOP单继承局限性
方法二:实现Runable接口,实现run方法
建议使用,避免了单继承局限性,灵活方便,方便同一个对象被多个线程使用
方法三:实现Callable接口,实现call方法
方法四:线程池
方法一:继承Thread类
-
定义MyThread类继承Thread方法
-
重写run方法,编写线程执行体
-
创建线程对象,调用start方法启动线程
static Thread currentThread() 返回对当前正在执行的线程对象的引用
class MyThread extends Thread{
public void run{
//逻辑处理
}
}
//主函数内的启动方式:
MyThread myThread = new MyThread();
myThread.start();
实例:
//创建线程方式一:继承Thread类,重写run()方法,调用start开启线程
public class TestThread1 extends Thread{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 100; i++) {
System.out.println("我在执行test1线程--->"+i);
}
}
public static void main(String[] args) {
//main线程
//创建一个线程对象
Thread threadtest1 = new TestThread1();
//调用start()方法开启线程
threadtest1.start();
for (int i = 0; i <100 ; i++) {
System.out.println("我在执行main线程--->"+i);
}
}
}
方法二:实现Runable接口
-
定义MyRunable类实现Runable接口
-
实现run方法,编写线程执行体
-
创建线程对象,调用start方法启动线程
class MyRunnable implements Runnable{
public void run{
//逻辑处理
}
}
//主函数内的启动方式
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
实例1:
//创建线程方式二:实现Runable类,实现run()方法,调用start开启线程
public class TestThread2 implements Runnable {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 100; i++) {
System.out.println("我在执行test2线程--->" + i);
}
}
public static void main(String[] args) {
//创建runable接口的实现类对象
TestThread2 testThread2 = new TestThread2();
//创建线程对象,通过线程对象开启我们的线程,代理
Thread thread = new Thread(testThread2);
thread.start();
for (int i = 0; i <100 ; i++) {
System.out.println("我在执行main线程--->"+i);
}
}
}
实例2:
package com.DuoXianCheng;
import com.sun.javafx.sg.prism.web.NGWebView;
/**
* currentThread()
* 返回当前线程
*线程的休眠
* 在当前的线程的执行过程中,暂停指定的毫秒数,释放CPU的时间片
*/
public class ThreadDemo1 {
public static void main(String[] args) {
//继承Thread类 启动方式
MyThread myThread = new MyThread();
myThread.start();//启动线程
//实现Runnable接口 启动方式
MyRunnable myRunnable=new MyRunnable();
Thread thread =new Thread(myRunnable);
thread.start();//启动线程
}
}
/**
* 实现线程的第一种方式:继承Thread类
*/
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i <50 ; i++) {
System.out.println(Thread.currentThread().getName()+"-"+i);
//线程的休眠
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
* 实现线程的第二种方式:实现Runnable接口
*/
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i <50 ; i++) {
System.out.println(Thread.currentThread().getName()+"-"+i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
方法三:实现Callable接口
-
定义MyCallable类实现Callable接口,泛型为call方法的返回值
-
实现call方法,编写线程执行体
-
创建线程对象,调用start方法启动线程
class MyCallable implements Callable<T>{
public T call{
//逻辑处理
return ;
}
}
//主函数内的启动方式
MyCallable myCallable = new MyCallable ();
FutureTask<T> future= new FutureTask<T>(myCallable) ;
//FutureTask类是Runnable接口的子类,所以可以使用Thread类的构造来接收FutureTask的实例化对象
new Thread(future).start();
System.out.println("线程的返回结果:" + future.get()) ;