Java多线程

最新推荐文章于 2022-06-13 22:56:52 发布

WustCxh

最新推荐文章于 2022-06-13 22:56:52 发布

阅读量150

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/peixie9441/article/details/80773723

版权

Java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1. 创建多线程的四种方式

一、继承Thread类创建线程类

(1) 定义Thread类的子类，并重写该类的run方法，该run方法的方法体代表了线程要完成的任务，称为执行体。

(2) 创建Thread子类的实例，即创建了线程对象。

(3) 调用线程对象的start()方法来启动线程。

package com.thread;

public class FirstThreadTest extends Thread{
int i = 0;
//重写run方法，run方法的方法体就是现场执行体
public void run()
{
for(;i<100;i++){
System.out.println(getName()+" "+i);
}
}
public static void main(String[] args)
{
for(int i = 0;i< 100;i++)
{
System.out.println(Thread.currentThread().getName()+" : "+i);
if(i==20)
{
new FirstThreadTest().start();
new FirstThreadTest().start();
}
}
}
}

二、通过Runnable接口创建线程类

(1) 创建Runnable接口的实现类，并重写该实现类的run方法。

(2) 创建Runnable接口实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

(3) 调用线程对象的start()方法来启动线程。

package com.thread;

public class RunnableThreadTest implements Runnable
{

private int i;
public void run()
{
for(i = 0;i <100;i++)
{
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
public static void main(String[] args)
{
for(int i = 0;i < 100;i++)
{
System.out.println(Thread.currentThread().getName()+" "+i);
if(i==20)
{
RunnableThreadTest rtt = new RunnableThreadTest();
new Thread(rtt,"新线程1").start();
new Thread(rtt,"新线程2").start();
}
}
}
}

三、通过Callable和Futrue创建线程

(1) 创建Callable接口的实现类，并实现call()方法，该call()方法作为线程执行体，并且有返回值。

(2) 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

(3) 使用FutureTask对象作为Thread对象的target创建并启动新线程。

(4) 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

package com.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableThreadTest implements Callable<Integer>
{

public static void main(String[] args)
{
CallableThreadTest ctt = new CallableThreadTest();
FutureTask<Integer> ft = new FutureTask<>(ctt);
for(int i = 0;i < 100;i++)
{
System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
if(i==20)
{
new Thread(ft,"有返回值的线程").start();
}
}
try
{
System.out.println("子线程的返回值："+ft.get());
} catch (InterruptedException e)
{
e.printStackTrace();
} catch (ExecutionException e)
{
e.printStackTrace();
}

}

@Override
public Integer call() throws Exception
{
int i = 0;
for(;i<100;i++)
{
System.out.println(Thread.currentThread().getName()+" "+i);
}
return i;
}

}

四、通过线程池创建线程

利用线程池不用new就可以创建线程，线程可复用，利用Executors创建线程池。

2. 创建线程的三种方式的对比

一、采用实现Runnable、Callable接口的方式创建多线程

优势：

线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。

在这种方式下，多个线程可以共享线程类（线程的target类）的实例变量，所以非常适合多个相同线程来处理同一份资源的情况。

劣势：

编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

二、使用继承Thread类的方式创建多线程

优势：

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势：

线程类继承了Thread类，所有不可以继承其他父类。

在这种方式下，多个线程之间无法共享线程类的实例变量。

三、Java中Runnable和Callable有什么不同

(1) Callable规定（重写）的方法是call()，Runnable规定（重写）的方法是run()。

(2) Callable的任务执行后可以有返回值，而Runnable的任务是不能有返回值的。

(3) call方法可以抛出异常，run方法不可以。

3. 线程的生命周期

当线程被创建并启动之后，它既不是一启动就进入执行状态，也不是一直处于执行状态，在线程的生命周期中，它要经过新建（New）、就绪（Runnable）、运行（Runnable）、阻塞（Blocked）和死亡（Dead）。

一、新建和就绪状态

使用new关键字创建一个线程之后，该线程处于新建状态，由Java虚拟机为其分配内存，并初始化其成员变量的值。

对象调用start()方法之后，该线程处于就绪状态，Java虚拟机为其创建方法调用栈和程序计数器，该状态的线程并没有立即开始运行，只是表示该线程可以运行了。至于该线程何时开始运行，取决JVM里线程调度器的调度。

如果直接调用线程对象的run()方法，则run()方法立即就会执行，系统把线程对象当成一个普通对象。

二、运行和阻塞状态

就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态。

当发生如下情况时，线程将会进入阻塞状态：

1. 线程调用sleep方法主动放弃所占用的处理器资源。

2. 线程调用了一个阻塞式IO方法，在该方法返回之前，该线程被阻塞。

3.线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有。

4. 线程在等待某个通知notify。

5. 程序调用了线程的suspend方法将该线程挂起，容易导致死锁，不建议使用该方法。

当前正在执行的线程被阻塞之后，其他线程就可以获得执行机会，被阻塞的线程会在合适的时候重新进入就绪状态，不是运行状态。

线程从阻塞状态只能进入就绪状态，无法直接进入运行状态。就绪和运行状态之间的转换不受程序所控制，由系统线程调度所决定。

三、死亡状态

线程会以如下三种方式之一结束，结束后就处于死亡状态：

1. run()方法执行完成，线程正常结束。

2. 线程抛出一个未捕获的Exception或Error。

3. 直接调用该线程的stop()方法来结束该线程，容易导致死锁，不推荐使用。

4. 控制线程

一、 join线程

join()方法：让一个线程等待另一个线程完成的方法。当在某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到被join()方法加入的join线程执行完为止。

二、后台线程

为其他线程提供服务。

特征：如果所有前台线程都死亡，后台线程会自动死亡。

设置后台线程：调用Thread对象的setDaemon(true)将某个线程设置为后台线程。

将某个线程设置为后台线程，必须在该线程启动之前设置。

三、线程睡眠：sleep

让当前正在执行的线程暂停一段时间，并进入阻塞状态，Thread.sleep()。

四、线程让步：yield

让当前正在执行的线程暂停，但它不会阻塞该线程，它只是将该线程转入就绪状态。Thread.yield()。

当某个线程调用yield()方法暂停之后，只有优先级与当前线程相同，或者优先级比当前线程更高的处于就绪状态的线程才会获得执行的机会。

sleep()和yield()方法的区别

sleep()方法暂停当前线程后，会给其他线程执行的机会，不会理会其他线程的优先级；yield()方法只会给优先级相同或者更高的线程执行机会。

sleep()方法会将线程转入阻塞状态，直到经过阻塞时间才会进入就绪状态；yield()方法会将线程转入就绪状态。

sleep()方法声明抛出了InterruptedException异常，所以用sleep()方法时要么捕获该异常，要么显式声明抛出该异常；yield()方法不会抛出任何异常。

5. 多线程的同步

在多线程的环境中，经常会遇到数据的共享问题，即当多个线程需要访问同一资源时，他们需要以某种顺序来确保该资源在某一时刻只能被一个线程使用，否则，程序的运行结果将会是不可预料的，在这种情况下，就必须对数据进行同步。

一、synchronized的用法

1. 同步代码块

synchronized(obj）同步监视器

{

}

线程开始执行同步代码块之前，必须先获得对同步监视器的锁定。

表示线程在执行的时候会将object对象上锁（这个对象可以是任意类的对象，也可以使用this关键字或者是class对象）。

synchronized块是一种细粒度的并发控制，只会将块中的代码同步，位于方法内，synchronized块之外的其他代码可以被多个线程同时访问到的。

2. 修饰非静态的方法

Java中的每个对象都有一个锁（lock），或者叫监视器，当一个线程访问某个对象的synchronized方法时，将该对象上锁，其他任何线程都无法访问该对象的synchronized方法，直到之前的那个线程执行方法完毕后（或者是抛出了异常），才会将该对象的锁释放掉，其他线程才有可能再去访问该对象的synchronized方法。

3. 修饰静态的方法

当一个synchronized关键字修饰的方法同时又被static修饰，它会将这个方法所在的类的Class对象上锁。一个类不管生成多少个对象，它们对应的是同一个Class对象。

6. 线程间的通信

一、wait()\notify()\notifyAll()的用法

首先，wait、notify方法是针对对象的，调用任意对象的wait()方法都将导致线程的阻塞，阻塞的同时也将释放该对象的锁，相应地，调用任意对象的notify()方法则将随机解除该对象阻塞的线程，但它需要重新获取该对象的锁，直到获取成功才往下执行；其次，wait、notify方法必须在synchronized块或方法中被调用，并且要保证同步块或方法的锁对象与调用wait、notify方法的对象是同一个，如此一来在调用wait之前当前线程就已经成功获取某对象的锁，执行wait阻塞后当前线程就将之前获取的对象锁释放。

二、为什么wait()，notify()，notifyAll()等方法都定义在Object类中？

因为这三个方法都需要定义在同步代码块或同步方法中，这些方法的调用是依赖锁对象的，而同步代码块或同步方法中的锁对象可以是任意对象，那么被任意对象调用的方法一定定义在Object类中。

7. ThreadLocal的原理

ThreadLocal相当于一个容器，用于存放每个线程的局部变量。ThreadLocal实例通常来说是private static类型的。ThreadLocal可以给一个初始值，而每个线程都会获得这个初始值的一个副本，这样才能保证不同的线程都有一份拷贝。

一般情况下，通过ThreadLocal.set()到线程中的对象是该线程自己使用的对象，其他线程是访问不到的，各个线程中访问的是不同的对象。

向ThreadLocal中set的变量是由Thread线程对象自身保存的，当用户调用ThreadLocal对象的set（Object o）时，该方法则通过Thread.currentThread()获取当前线程，将变量存入线程中的ThreadLocalMap类的对象内，Map中元素的键为当前的ThreadLocal对象，而值对应线程的变量副本。