java多线程教程那些事 java多线程入门

转载

liutao988 2023-06-09 13:52:28

文章标签 精通java多线程 java 同步方法 System ide 文章分类 Java 后端开发

介绍：Java提供了非常优秀的多线程支持，程序可以通过非常简单的方式来启动多线程。本章主要内容为：多线程的创建、启动、控制以及同步操作，并介绍JDK 5新增的线程创建方式。

一、线程的创建与使用：

　　1. 继承Thread类创建线程：

建立一个继承Thread的子类
重写Thread类的run()--把所执行的操作写在该方法中
创建一个子类对象
通过该对象调用start()方法

1 //1.1. 建立一个继承Thread的子类
 2 class MyThread1 extends Thread{
 3     @Override
 4     //1.2. 重写Thread类的run()
 5     public void run() {
 6         for(int i=0;i<100;i++){
 7             if(i%2==0){
 8                 System.out.println(getName() + ":" + i);//Thread.currentThread().getName()
 9             }
10         }
11     }
12 }
13 
14 //1.3. 创建一个子类对象
15 MyThread1 t1 = new MyThread1();
16 t1.setName("线程1");
17 
18 //1.4. 通过该对象调用start()方法
19 t1.start();//注意，一个线程对象不能同时两次start，需要重新创建一个对象来start

　　2. 实现Runnable接口创建线程：

建立一个Runnable接口的实现类
实现Runnable中的抽象方法run()
创建实现类对象
将此对象作为参数传递到Thread类的构造器中，创建一个Thread类的对象
通过Thread类的对象调用start()方法

1 //2.1 建立一个Runnable接口的实现类
 2 class MyThread2 implements Runnable{
 3     //2.2. 实现Runnable中的抽象方法run()
 4     @Override
 5     public void run() {
 6         for(int i=0;i<100;i++){
 7             if(i%2==0){
 8                 System.out.println(Thread.currentThread().getName() + ":" + i);
 9             }
10         }
11     }
12 }
13 
14 //2.3 2.4 创建实现类对象，将此对象作为参数传递到Thread类的构造器中，创建一个Thread类的对象
15 Thread t2 = new Thread(new MyThread2());
16 t2.setName("线程2");
17 
18 //2.5. 通过Thread类的对象调用start()方法
19 t2.start();

　　开发中优先选择后者：既没有类的单继承性的限制，而且实现的方式更适合来处理多个线程有共享数据的情况。

　　3. 实现Callable接口创建线程：

创建一个Callable接口的实现类
实现call方法，将此线程需要执行的操作写在方法体中
创建Callable接口实现类的对象
将上面的实现类对象作为参数创建FutureTask的对象
将上面的FutureTask的对象作为参数创建Thread的对象
利用Thread的对象调用start方法
通过 FutureTask的对象.get() 方法获取call方法的返回值

1 //3.1 创建一个Callable接口的实现类
 2 class NumThread implements Callable{
 3     @Override
 4     //3.2 实现call方法，将此线程需要执行的操作写在方法体中
 5     public Object call() throws Exception {
 6         int sum = 0;
 7         for(int i=1;i<=100;i++){
 8             if(i%2==0){
 9                 System.out.println(i);
10                 sum += i;
11             }
12         }
13         return sum;
14     }
15 }
16 
17 //3.3 创建Callable接口实现类的对象
18 NumThread num = new NumThread();
19 //3.4 将上面的实现类对象作为参数创建FutureTask的对象
20 FutureTask futureTask = new FutureTask(num);
21 //3.5 将上面的FutureTask的对象作为参数创建Thread的对象
22 Thread t = new Thread(futureTask);
23 t.setName("线程3");
24 //3.6 利用Thread的对象调用start方法
25 t.start();
26 
27 try {
28     //3.7 通过 FutureTask的对象.get() 方法获取call方法的返回值
29     Object sum = futureTask.get();//get方法的返回值即为NumThread.call的返回值
30     System.out.println("共计：" + sum);
31 } catch (InterruptedException e) {
32     e.printStackTrace();
33 } catch (ExecutionException e) {
34     e.printStackTrace();
35 }

　　相较于Runnable接口更强大、可以抛出异常、支持泛型，但是需要借助FutureTask类

　　4. 使用线程池创建线程：

创建指定线程数量的线程池
执行指定的线程的操作，需要提供一个实现Runnable获Callable接口的对象
关闭连接池

1 class MyThread2 implements Runnable{
 2     @Override
 3     public void run() {
 4         for(int i=0;i<100;i++){
 5             if(i%2==0){
 6                 System.out.println(Thread.currentThread().getName() + ":" + i);
 7             }
 8         }
 9     }
10 }
11 
12 //4.1 创建指定线程数量的线程池
13 ExecutorService service = Executors.newFixedThreadPool(10);//创建确定个数的线程池
14 // 4.2 执行指定的线程的操作，需要提供一个实现Runnable获Callable接口的对象
15 service.execute(new MyThread2());//参数只能是Runnable
16 service.execute(new MyThread3());//参数只能是Runnable
17 //4.3 关闭连接池
18 service.shutdown();

　　 5. Thread类中常见的方法：

void start(): 启动线程,并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static Thread currentThread(): 返回当前线程。在Thread子类中就是this,通常用于主线程和Runnable实现类
static void yield(): 线程让步，暂停当前正在执行的线程,把执行机会让给优先级相同或更高的线程，若队列中没有同优先级的线程,忽略此方法
join() : 当某个程序执行流中调用其他线程的 join() 方法时,调用线程将被阻塞,直到 join() 方法加入的 join 线程执行完为止，使得低优先级的线程也可以获得执行
static void sleep(long millis):(指定时间:毫秒)令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。（抛出InterruptedException异常）
stop(): 强制线程生命期结束,不推荐使用
boolean isAlive(): 返回boolean,判断线程是否还活着

//给线程命名--方式一：通过setName()
t1.setName("线程1");                             //设置该线程名称

//给线程命名--方式二：通过构造器
ThreadMethodTest2 t2 = new ThreadMethodTest2("*线程2");

　　6. 线程优先级：

MAX_PRIORITY:10
MIN _PRIORITY:1
NORM_PRIORITY:5

　　涉及的方法：

getPriority() :返回线程优先值
setPriority(int newPriority) :改变线程的优先级

　　说明：

线程创建时继承父线程的优先级
低优先级只是获得调度的概率低,并非一定是在高优先级线程之后才被调用

二、线程的同步：

　　1. 同步代码块：

synchronized (同步监视器){
    // 需要被同步的代码;
}

　　同步监视器：俗称锁。任何一个类的对象都可以充当锁，要求多个线程必须共用同一个锁。

Runnable接口的方式的所可以使用this，因为它自始至终只用了一个对象
继承Thread类的方式不能用this，可以使用类.class 来充当

　　2. 同步方法：synchronized放在方法声明中,表示整个方法为同步方法。同步方法仍然涉及同步监视器，但无需显示说明，例如:

public synchronized void show (String name){
    ....
}

　　3. lock锁：

//1. 实例化ReentrantLock
try{
    //2. 调用lock
    //需要被同步的代码
}finally{
    //3. 调用unlock
}

　　4. 案例：

java多线程教程那些事 java多线程入门_ide