Java学习笔记整理: 关于多线程 2024/7/3；

多线程常用方法:

//获取当前线程对象        获取对象名
Thread.currentThread().getName();
//延迟执行时间 单位毫秒
Thread.sleep(20);

线程定义:

线程，又称轻量级进程(Light Weight Process) 线程是进程中的一条执行路径，也是CPU的基本调度单位。若一个程序可同一时间执行多个线程，就是支持多线程的. 一个进程由一个或多个线程组成，彼此间完成不同的工作(任务)，同时执行，称为多线程。

为什么使用多线程:

多线程能提高cpu的利用率,提升运行效率;

创建多线程:

Java中提供了三种实现多线程的方式:

第一种: 继承Thread类

第二种: 实现Runnable接口

第三种: 实现Callable接口

Thread:

package com.gzx.thread;
​
//继承Thread类
public class MyThreadOne extends Thread{
​
    //重写run()方法
    @Override
    public void run() {
        System.out.println("线程1正在执行");
        
        //获取当前线程对象        获取对象名
        Thread.currentThread().getName();
        }
    }
}

package com.gzx;
​
import com.gzx.thread.MyThreadOne;
import com.gzx.thread.MyThreadTwo;
​
public class Main {
    public static void main(String[] args) {
        System.out.println("主线程启动");
        //引入线程对象
        MyThreadOne myThreadOne = new MyThreadOne();
        //启用该对象线程
        myThreadOne.start();
    }
}

Runnable:

package com.gzx.runnable;
​
//实现Runnable接口
public class MyRunnableOne implements Runnable{
    
    //重写run()方法
    @Override
    public void run() {
        System.out.println("MyRunnableOne is running");
    }
}

Callable:

package com.gzx.callable;
​
import java.util.concurrent.Callable;
​
//实现Callable<类>接口
public class MyCallableOne implements Callable<Integer> {
    
    //重写call()方法
    @Override
    public Integer call() throws Exception {
        // 定义一个整数变量nums，初始值为0
        Integer nums = 0;
        // 使用for循环，循环条件为3*i<1000，循环变量i从0开始
        for (int i = 0; 3*i <= 1000; i++) {
            // 将3*i的值加到nums上
            nums+=3*i;
        }
        // 返回nums的值
        return nums;
    }
}

package com.gzx;
​
import com.gzx.callable.MyCallableOne;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
​
public class MainThree {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建多线程对象
        MyCallableOne myCallableOne = new MyCallableOne();
        //把call对象封装到FutureTask类中 
        //而且任务执行的结果也在FutureTask
        FutureTask task = new FutureTask(myCallableOne);
        Thread thread = new Thread(task);
        //开启该对象线程
        thread.start();
        //获取该对象返回值
        Object o = task.get();
        //输出
        System.out.println(o);
    }
}

其中多为自我理解进行总结,可能会有错误,仅供参考