彻底搞懂Java多线程(一)

Java多线程

线程的创建

1.继承Thread

2.实现Runnable

3.实现Callable

使用继承Thread类来开发多线程的应用程序在设计上是有局限性的，因为Java是单继承。

继承Thread类

1. public class ThreadDemo1 {
2. // 继承Thread类 写法1
3. static class MyThread extends Thread{
4. @Override
5. public void run() {
6. //要实现的业务代码
7. }
8. }
9. // 写法2
10. Thread thread = new Thread(){
11. @Override
12. public void run() {
13. //要实现的业务代码
14. }
15. };
16. }

实现Runnable接口

1. //实现Runnable接口 写法1
2. class MyRunnable implements Runnable{
3. @Override
4. public void run() {
5. //要实现的业务代码
6. }
7. }
8. //实现Runnable接口 写法2 匿名内部类
9. class MyRunnable2 {
10. public static void main(String[] args) {
11. Thread thread = new Thread(new Runnable() {
12. @Override
13. public void run() {
14. //要实现的业务代码
15. }
16. });
17. }
18. }

实现Callable接口（Callable + FutureTask 创建带有返回值的线程）

1. package ThreadDeom;
2. import java.util.concurrent.Callable;
3. import java.util.concurrent.ExecutionException;
4. import java.util.concurrent.FutureTask;
5. /**
6. * user：ypc；
7. * date：2021-06-11;
8. * time: 17:34;
9. */
10. //创建有返回值的线程 Callable + Future
11. public class ThreadDemo2 {
12. static class MyCallable implements Callable<Integer>{
13. @Override
14. public Integer call() throws Exception {
15. return 0;
16. }
17. }
18. public static void main(String[] args) throws ExecutionException, InterruptedException {
19. //创建Callable子对象
20. MyCallable myCallable = new MyCallable();
21. //使用FutureTask 接受 Callable
22. FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
23. //创建线程并设置任务
24. Thread thread = new Thread(futureTask);
25. //启动线程
26. thread.start();
27. //得到线程的执行结果
28. int num = futureTask.get();
29. }
30. }

也可以使用lambda表达式

1. class ThreadDemo21{
2. //lambda表达式
3. Thread thread = new Thread(()-> {
4. //要实现的业务代码
5. });
6. }

Thread的构造方法

线程常用方法

获取当前线程的引用、线程的休眠

1. class Main{
2. public static void main(String[] args) throws InterruptedException {
3. Thread.sleep(1000);
4. //休眠1000毫秒之后打印
5. System.out.println(Thread.currentThread());
6. System.out.println(Thread.currentThread().getName());
7. }
8. }

1. package ThreadDeom;
2. /**
3. * user：ypc；
4. * date：2021-06-11;
5. * time: 18:38;
6. */
7. public class ThreadDemo6 {
8. public static void main(String[] args) throws InterruptedException {
9. Thread thread = new Thread(new Runnable() {
10. @Override
11. public void run() {
12. System.out.println("线程的ID：" + Thread.currentThread().getId());
13. System.out.println("线程的名称：" + Thread.currentThread().getName());
14. System.out.println("线程的状态：" + Thread.currentThread().getState());
15. try {
16. Thread.sleep(1000);
17. } catch (InterruptedException e) {
18. e.printStackTrace();
19. }
20. }
21. },"线程一");
22. thread.start();
23. Thread.sleep(100);
24. //打印线程的状态
25. System.out.println("线程的状态："+thread.getState());
26. System.out.println("线程的优先级："+thread.getPriority());
27. System.out.println("线程是否存活："+thread.isAlive());
28. System.out.println("线程是否是守护线程："+thread.isDaemon());
29. System.out.println("线程是否被打断："+thread.isInterrupted());
30. }
31. }

线程的等待

假设有一个坑位，thread1 和 thread2 都要上厕所。一次只能一个人上，thread2只能等待thread1使用完才能使用厕所。就可以使用join()方法，等待线程1执行完，thread2在去执行。