目录
一、继承Thread类
-
继承Thread类创建并启动多线程的步骤如下：
-
定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
-
创建Thread子类的实例，即创建了线程对象
-
调用线程对象的start()方法来启动该线程
-
-
定义线程类
public class MyThread extends Thread {
/**
* 重写run方法，完成该线程执行的逻辑
*/
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("HelloWolrd!"+i);
}
}
}- 测试类
public class Demo01 {
public static void main(String[] args) {
// MyThread my = new MyThread();
//这不是启动线程，相当于调了run()方法，只是普通调用
// my.run();
// my.run();
//IllegalThreadStateException 非法的线程态态异常
//为什么呢？ 因为你启动两次，并不是两个线程
// my.start();
// my.start();
MyThread my = new MyThread();
MyThread my2 = new MyThread();
my.start();
my2.start();
}
}获取名字和设置名字
public class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName()+" : "+i);
}
}
} public static void main(String[] args) {
MyThread my = new MyThread();
MyThread my2 = new MyThread();
my.setName("jack");
my2.setName("rose");
my.start();
my2.start();
}二、实现Runnable接口
采用 java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。
-
实现Runnable接口创建并启动多线程的步骤如下：
1.定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2.创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
3.调用线程对象的start()方法来启动线程。
-
Runnable接口
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+" : "+i);
}
}
}- 测试类
public static void main(String[] args) {
MyRunnable my = new MyRunnable();
//起名字方式1
// Thread t1 = new Thread(my,"jack");
// Thread t2 = new Thread(my,"rose");
Thread t1 = new Thread(my);
Thread t2 = new Thread(my);
//起名字方式2
t1.setName("jack");
t2.setName("rose");
//启动线程
t1.start();
t2.start();
}通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target)构造出对象，然后调用Thread 对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现
Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。
三、实现Callable接口
Callable接口是一个函数式接口，因此可以用作lambda表达式或方法引用的赋值对象。
函数式接口：首先是接口，这个接口里面，有且仅有一个方法需要你实现，就称之为函数式接口。
lambda 表达式只能简化函数式接口的写法。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
class MyCall implements Callable<Integer>{
@Override
public Integer call() throws Exception {
return 200;
}
}
class MyRun implements Runnable{
@Override
public void run() {
System.out.println("我是子线程....");
}
}
public class Demo08 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<Integer> futureTask = new FutureTask<>(new MyCall());
new Thread(futureTask,"计算线程").start();
Integer i = futureTask.get();
System.out.println(i);
// --------------------------------------
new Thread(new MyRun()).start();
// ------------------使用callable 模拟 子线程进行大量计算并返回结果------------------
FutureTask<Integer> f1 = new FutureTask<>(
()->{
System.out.println(Thread.currentThread().getName()+" come in callable");
TimeUnit.SECONDS.sleep(4);
return 1024;
}
);
FutureTask<Integer> f2 = new FutureTask<>(
()->{
System.out.println(Thread.currentThread().getName()+" come in callable");
TimeUnit.SECONDS.sleep(4);
return 2048;
}
);
new Thread(f1,"线程一：").start();
new Thread(f2,"线程二：").start();
while(!f1.isDone()){
System.out.println("f1 wait中.....");
}
while(!f2.isDone()){
System.out.println("f2 wait中.....");
}
// 其实 get 获取不到值会一直阻塞，直到获取到值为止
int a = f1.get();
int b = f2.get();
System.out.println(a+b);
}
}四、线程池
线程池的优势：
线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。
它的主要特点为：线程复用;控制最大并发数;管理线程。
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
第二：提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。
第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
Java中的线程池是通过Executor框架实现的，该框架中用到了Executor，Executors，ExecutorService，ThreadPoolExecutor这几个类。
经常使用的线程池做法：
1、Executors.newFixedThreadPool(int)
执行长期任务性能好，创建一个线程池，一池有N个固定的线程，有固定线程数的线程
newFixedThreadPool创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的是LinkedBlockingQueue
2、Executors.newSingleThreadExecutor()
一个任务一个任务的执行，一池一线程。
newSingleThreadExecutor 创建的线程池corePoolSize和maximumPoolSize值都是1，它使用的是LinkedBlockingQueue
3、Executors.newCachedThreadPool()
执行很多短期异步任务，线程池根据需要创建新线程，但在先前构建的线程可用时将重用它们。可扩容，遇强则强。
newCachedThreadPool创建的线程池将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，它使用的是SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程。
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MyThreadPoolDemo {
public static void main(String[] args) {
// ExecutorService threadPool = Executors.newFixedThreadPool(5); //一个银行网点，5个受理业务的窗口
// ExecutorService threadPool = Executors.newSingleThreadExecutor(); //一个银行网点，1个受理业务的窗口
ExecutorService threadPool = Executors.newCachedThreadPool(); //一个银行网点，可扩展受理业务的窗口
//10个顾客请求
try {
for (int i = 1; i <=10; i++) {
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+"\t 办理业务");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPool.shutdown();
}
}
}
扫一扫
369
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
