一、线程
1.概念:
线程(英语:thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程(lightweight processes),但轻量进程更多指内核线程(kernel thread),而把用户线程(user thread)称为线程。——————来自百度百科
2.多线程的优点
①提供应用程序的响应,对图形化界面更有意义,可增强用户体验。
②提高计算机CPU的利用率
③改善程序结构。即将长又复杂的进程分为多个线程,独立运行,利于理解和修改。
3.何时需要多线程
①提高应用程序同时执行两个或多个任务。
②程序需要实现一些需要等待的任务时,如用户输入,文件读写操作,网络操作,搜索等。
③需要后台运行的程序时。
比如说我们在运行360的时候,由于360这个应用程序比较大。而且模块也比较多,所以把这个较大的应用程序分为多线程,在后台应用可以看见他们的运行情况以及占了多少CPU等,如图:
在后台可以看见应用程序的运行,也就是说把一个进程分成了多线程进行执行。
4.线程类的特性
java语言的JVM允许运行多个线程,它通过java.lang.Thread类来体现。
①把每个线程都是通过某个特定的Thread对象的run()方法来完成操作的,经常把run()方法的主体称为线程体。
②通过该Thread对象的start()方法来启动这个线程,而非直接调用。
二、多线程的创建方式
方式一:继承Thread类创建线程
1).d定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体。
2).创建Thread子类的实例,也就是创建了线程对象
3).启动线程,即调用线程的start()方法
实现代码:以卖票为例
创建一个继承Thread的子类
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":" + i);
}
}
}
}
测试类,启动通过对象调用start()方法启动线程。
public class ThreadTest {
public static void main(String[] args) {
//3.创建Thead类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start:①启动当前线程 ②调用当前线程run()
t1.start();
//问题一:不能通过直接调用run()的方法启动线程
// t1.run();
//问题二:再启动一个线程,遍历100以内的偶数,不可以还让已经start()的线程去执行,会报异常
//t1.start();
//我们需要创建一个线程对象。
MyThread t2= new MyThread();
t2.start();
//如下操作仍然是在main线程中执行。
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":" + "*************main()**********"+i );
}
}
}
}
Thread中常用的方法
1.start():启动当前线程,调用当前线程的run()
2.run():通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中。
3.currentThread():静态方法,返回执行当前代码线程。
4.getName():获取当前线程的名字
5.setName():设置当前线程的名字。
6.yield():释放当前cpu的执行权.
7.join():在线程A中调用线程B的join(),此时线程A就进入阻塞状态,直到线程B完全执行完以后,线程a才会结束阻塞状态。
8.stop():已过时,当执行此方法时,强制结束当前线程
9.sleep(longmillitime):让当前线程睡眠制定的millitime毫秒,在指定的millitime毫秒时间内,当前线程是阻塞状态
10.isAlive():判断当前线程是否存活
方式二:实现Runnable接口
1.创建一个实现了Runnable接口的类
2.实现类实现Runnable中的抽象类的方法run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
5.通过Thread类的对象调用start();
实现代码
测试类
public class ThreadTest1 {
public static void main(String[] args) {
MThread mThread=new MThread();
Thread t1=new Thread(mThread);
t1.setName("线程一");
//通过Thread类的对象调用start(); ①启动当前线程 ②调用当前线程的run();
t1.start();
//再启动一个线程,遍历100以内的偶数
Thread t2=new Thread(mThread);
t2.setName("线程二");
t2.start();
}
}
实现Runnable接口
class MThread implements Runnable{
//实现类实现Runnable中的抽象类的方法run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2 == 0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
方式三:实现Callable接口
1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。
2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。
3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
实现代码
Callable的实现类
class NumThread implements Callable{
//2.实现call方法,将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum=0;
for (int i =1; i <= 100; i++) {
if (i%2 == 0) {
System.out.println(i);
sum +=i;
}
}
return sum;
}
}
测试类
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread=new NumThread();
//4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中,创建FuntureTask对象。
FutureTask futureTask= new FutureTask(numThread);
//5.将FuntureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start();
new Thread(futureTask).start();
try{
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()返回值。
Object sum = futureTask.get();
System.out.println("总和为"+sum);
}catch (InterruptedException e){
e.printStackTrace();
}catch (ExecutionException e){
e.printStackTrace();
}
}
}
方式四:使用线程池
*好处:
1).提高响应速度(减少了创建新线程的时间)
2).降低资源消耗(重复利用线程池中线程,不需要每次都创建)
3).便于线程管理
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止
线程池实现类
class NumberThread implements Runnable{
public void run(){
for (int i = 0; i <100 ; i++) {
if (i %2==0) {
System.out.println(Thread.currentThread().getName()+":"+ i);
}
}
}
}
测试类
public class ThreadPool {
public static void main(String[] args) {
//1.提供制定线程数量的线程池
//Excutors相当于一个工具类。
ExecutorService service= Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1=(ThreadPoolExecutor) service;
//设置线程池的属性
System.out.println(service.getClass());
service1.setCorePoolSize(15);
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
//service.submit();//适合适用于Callable
//3.关闭连接池
service.shutdown();
}
}
关于Thread与Runnable的详情,可以参考以下文章。
Thread和Runnable的异同