一、方式1:继承Thread类
步骤:
- 创建一个继承于Thread类的子类
- 重写Thread类的run()方法 —-> 此线程执行的操作声明在方法体中
- 创建当前Thread子类的对象
- 通过实例对象调用start()方法,启动线程 —-> Java虚拟机会调用run()方法
注意main()方法是主线程
1. 创建线程:
//自定义线程类
public class MyThread extends Thread {
// 共享数据要放在run()方法外边才能被共享且声明为static,否则就是每个线程都会调用run()方法,都会单独拥有一个run()方法里的独享数据,而非共享数据
//eg: static int trick = 100;
//定义指定线程名称的构造方法
public MyThread(String name) {
//调用父类的String参数的构造方法,指定线程的名称
super(name);
}
/**
* 重写run方法,完成该线程执行的逻辑
*/
@Override
public void run() {
// 执行的操作
}
}
2. 调用线程:
public class TestMyThread {
public static void main(String[] args) {
//创建自定义线程对象1
MyThread mt1 = new MyThread("子线程1");
//开启子线程1
mt1.start();
//创建自定义线程对象2,分别创建对象开启线程,不可以数据共享,若要共享需要创建static变量
MyThread mt2 = new MyThread("子线程2");
//开启子线程2
mt2.start();
}
}
3. 创建Thread类的匿名子类的匿名对象
// 创建Thread类的匿名子类的匿名对象,并启动线程
new Thread(){
public void run(){
// 执行的操作
}
}.strat(); // 启动线程
二、方式2:实现Runnable接口
- 创建一个实现Runnable接口的类
- 实现接口中的run()方法 —-> 线程执行的操作声明在此方法中
- 创建实例对象
- 将此对象作为参数传到Thread类的构造器中,创建Thread类的实例
- 通过Thread的实例对象调用strat()方法,启动线程 —-> Java虚拟机会调用run()方法
最终还是通过Thread实现的
1. 创建线程:
public class MyRunnable implements Runnable {
// 共享数据要放在run()方法外边才能被共享,否则就是每个线程都会调用run()方法,都会单独拥有一个run()方法里的独享数据,而非共享数据
//eg: int trick = 100;
@Override
public void run() {
// 执行的操作
}
}
2. 调用线程
public class TestMyRunnable {
public static void main(String[] args) {
//创建自定义类对象 线程任务对象
MyRunnable mr = new MyRunnable();
//创建线程对象1
Thread t1 = new Thread(mr, "长江1");
t1.start();
//创建线程对象2,注意两个线程传入的是同一个对象,可以实现数据共享
Thread t2 = new Thread(mr, "长江2");
t2.start();
}
}
3. 创建Runnable接口的匿名子类的匿名对象
new Thread(new Runnable(){
public run(){
// 执行的操作
}
}).start(); // 开启线程
三、继承Thread类 VS 实现Runnable接口
1. 共同点:
- 都是通过Thread类中定义的start()来启动线程。
- 都是通过Thread类或其子类的实例对象来创建线程。
2. 不同点:
- Thread是继承
- Runnable是实现
3. Runnable好处:
- 通过实现的方式,避免了类的单继承的局限性
- 自动共享数据,更适合处理有共享数据的业务逻辑
- 实现了逻辑代码(在run()方法中)和数据(在创建线程的方法中)的分离
四、Thread类常用方法和生命周期
1 构造器
- public Thread() :分配一个新的线程对象。
- public Thread(String name) :分配一个指定名字的新的线程对象。
- public Thread(Runnable target) :指定创建线程的目标对象,它实现了Runnable接口中的run方法
- public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
2 常用方法系列1
- public void run() :此线程要执行的任务在此处定义代码。
- public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
- public String getName() :获取当前线程名称。
- public void setName(String name):设置该线程名称。
- public static Thread currentThread() :返回对当前正在执行的线程对象的引用。在Thread子类中就是this,通常用于主线程和Runnable实现类
- public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
- public static void yield():yield只是让当前线程暂停一下,让系统的线程调度器重新调度一次,希望优先级与当前线程相同或更高的其他线程能够获得执行机会,但是这个不能保证,完全有可能的情况是,当某个线程调用了yield方法暂停之后,线程调度器又将其调度出来重新执行。
3 常用方法系列2
-
public final boolean isAlive():测试线程是否处于活动状态。如果线程已经启动且尚未终止,则为活动状态。
-
void join() :等待该线程终止。
void join(long millis) :等待该线程终止的时间最长为 millis 毫秒。如果millis时间到,将不再等待。
void join(long millis, int nanos) :等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
-
public final void stop():
已过时
,不建议使用。强行结束一个线程的执行,直接进入死亡状态。run()即刻停止,可能会导致一些清理性的工作得不到完成,如文件,数据库等的关闭。同时,会立即释放该线程所持有的所有的锁,导致数据得不到同步的处理,出现数据不一致的问题。 -
void suspend() / void resume() : 这两个操作就好比播放器的暂停和恢复。二者必须成对出现,否则非常容易发生死锁。suspend()调用会导致线程暂停,但不会释放任何锁资源,导致其它线程都无法访问被它占用的锁,直到调用resume()。
已过时
,不建议使用。
4 常用方法系列3
每个线程都有一定的优先级,同优先级线程组成先进先出队列(先到先服务),使用分时调度策略。优先级高的线程采用抢占式策略,获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。
- Thread类的三个优先级常量:
- MAX_PRIORITY(10):最高优先级
- MIN _PRIORITY (1):最低优先级
- NORM_PRIORITY (5):普通优先级,默认情况下main线程具有普通优先级。
- public final int getPriority() :返回线程优先级
- public final void setPriority(int newPriority) :改变线程的优先级,范围在[1,10]之间。
5. 线程的生命周期
jdk1.5 之前的5种状态:
jdk1.5 之后的6种状态:
- 将准备和运行合并为一个Runnable状态
- 将阻塞细分为:计时等待、锁阻塞、无线等待3种状态
五、解决线程的安全问题
当多个线程同时操作同一个共享数据时,就会出现线程的安全问题。
方式一:synchronized 同步代码块
/**
* 1.同步监视器,俗称锁。哪个线程获得了锁,哪个线程就能执行该代码块
* 2.同步监视器可以是任何一个类的对象。但是,多个线程必须共用同一个同步监视器,且该对象是唯一的(只有一个实例对象)。
* >可以自定义一个专用于线程锁的类,然后在这里创建对象作为锁使用。
* >可以使用this充当锁,this指向当前对象。但是要注意当前类是否只创建了一个对象(保证唯一性)
* >在继承Thread的方式中不可以使用this,因为每一个线程都需要创建对象,不满足唯一性
* >在继承Thread的方式中,创建对象作为锁也需要声明为static的才可以,static Object obj = new Pbject();
* >可以使用“当前类.class”充当锁。因为“Class clz = 类.class”是一个类,仅加载一次,是全局唯一的(反射),该方式在实现Runnable中也可以使用
*
*/
synchronized(同步监视器){
// 需要被同步的代码,即操作共享数据的代码
}
方式二:synchronized 同步方法
/*
*用synchronized 直接修饰操作同步代码的方法
* 1.在非static的方法中,默认锁是:this。锁无法修改,因而在继承Thread方法中不适用,可以改成同步代码块方式,手动添加将当前类做为锁
* 2.在static的方法中,默认的锁是:当前类.class。即当前类本身。
*
*/
// 示例代码:在run()方法中调用show()方法
public synchronized void show(){
// 操作共享数据的代码
}
方式三(推荐):LOCK
Lock是 java.util.concurrent.locks(JUC)包下的一个接口
ReentrantLock可重复锁:
lock()和unlock()方法直接的代码,就会被加锁:
- lock:加锁
- unlock:释放锁
class A{
//1. 创建Lock的实例,必须确保多个线程共享同一个Lock实例,所以必须是static的,可以在加上final不让后续线程修改
private static final ReentrantLock lock = new ReenTrantLock();
public void m(){
//2. 调动lock(),实现需共享的代码的锁定
lock.lock();
try{
//保证线程安全的代码
}finally{
//3. 调用unlock(),释放共享代码的锁定。如果同步代码有异常,要将unlock()写入finally语句块,因为需要保证一定能解锁。
lock.unlock();
}
}
}
synchronized同步 VS Lock
synchronized:不管是同步方法还是同步代码块,都需要在一对{}之后释放锁。
Lock:
- 通过lock()和unlock()两个方法对代码加锁,更灵活。
- Lock作为接口,提供了多种实现类,适合更多更复杂的场景(读锁、写锁、读写锁…)。
- 效率也更高一些。
wait() VS sleep()
相同点: 一旦 执行,当前线程都会进入阻塞状态。
不同点:
- 声明位置不同:
- wait():声明在Object类中
- sleep():生命在Thread类中
- 使用场景不同
- wait():只能使用在synchronized同步代码块或同步方法中
- sleep():在一在任何场景使用
- 对锁的控制
- wait():一旦执行,会释放锁
- sleep():一旦执行,不会释放锁
- 结束阻塞的方式:
- wait():到达时间自动结束阻塞,或被notify()唤醒结束阻塞
- sleep():到达时间自动结束阻塞
六、死锁
不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁。
一旦出现死锁,整个程序既不会发生异常,也不会给出任何提示,只是所有线程处于阻塞状态,无法继续。
1. 诱发死锁的原因:
- 互斥条件:一个线程拿到了锁,在释放之前其他线程无法得到锁
- 占用且等待:拿着一个锁还在等待其他锁,导致无法继续执行
- 不可抢夺(或不可抢占):拿着一个锁还在等待其他锁的同时,其他线程先获取到了另一个锁,但是不能先执行
- 循环等待:一致保持不可抢夺的状态
2. 解决死锁方案
死锁一旦出现,基本很难人为干预,只能尽量规避。可以考虑打破上面的诱发条件。
- 针对条件1:互斥条件基本上无法被破坏。因为线程需要通过互斥解决安全问题。
- 针对条件2:可以考虑一次性申请所有所需的资源(获取所有需要用到的锁,用完后立即释放),这样就不存在等待的问题。
- 针对条件3:占用部分资源的线程在进一步申请其他资源时,如果申请不到(在一定时间内),就主动释放掉已经占用的资源。
- 针对条件4:可以将资源改为线性顺序(优先级)。申请资源时,先申请序号较小的,这样避免循环等待问题。
七、方式3:实现Callable接口
-
与使用Runnable相比, Callable功能更强大些
- 相比run()方法,call()可以有返回值,更灵活
- call()方法可以使用throws抛出异常,更灵活
- Callable使用泛型参数,可以指明具体的call()返回值类型,更灵活
-
Future接口(了解)
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
- FutureTask是Futrue接口的唯一的实现类
- FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值
-
缺点:在获取分线程执行结果的时候,当前线程(或是主线程)受阻塞,效率较低。
代码举例:
/*
* 创建多线程的方式三:实现Callable (jdk5.0新增的)
*/
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
//2.实现call方法,将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class CallableTest {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
new Thread(futureTask).start();
// 接收返回值
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为:" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
八、方式4(推荐):使用线程池
背景
如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间。
那么有没有一种办法使得线程可以复用,即执行完一个任务,并不被销毁,而是可以继续执行其他的任务?
思路: 提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。
好处:
- 提高了程序执行的效率(线程已经提前创建好了)
- 提高了资源复用率(执行完的线程并未销毁,还可以继续执行其他任务,不需要每次都创建)
- 可以设置相关参数,对线程池中的线程进行管理
- corePoolSize:核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后会终止
线程池相关API:
- JDK5.0之前,我们必须手动自定义线程池。从JDK5.0开始,Java内置线程池相关的API。在java.util.concurrent包下提供了线程池相关API:ExecutorService 和 Executors。
- ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command) :执行任务/命令,没有返回值,一般用来执行Runnable
- Future submit(Callable task):执行任务,有返回值,一般又来执行Callable
- void shutdown() :关闭连接池
- Executors:一个线程池的工厂类,通过此类的静态工厂方法可以创建多种类型的线程池对象。
- Executors.newCachedThreadPool():创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(int nThreads); 创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() :创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(int corePoolSize):创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。
// 这里使用实现Runnable的方式
class NumberThread implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread2 implements Callable {
@Override
public Object call() throws Exception {
int evenSum = 0;//记录偶数的和
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
evenSum += i;
}
}
return evenSum;
}
}
public class ThreadPoolTest {
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
// //设置线程池的属性
// System.out.println(service.getClass());//ThreadPoolExecutor
service1.setMaximumPoolSize(50); //设置线程池中线程数的上限
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
try {
Future future = service.submit(new NumberThread2());//适合使用于Callable
System.out.println("总和为:" + future.get());
} catch (Exception e) {
e.printStackTrace();
}
//3.关闭连接池
service.shutdown();
}
}
九、线程调度策略
分时调度: 所有线程轮流使用CPU的使用权,并且平均分配每个线程占用CPU的时间。
抢占式调度: 优先级高的线程使用CPU的概率大些。如果线程优先级相同,则会随机选择一个(线程随机性),Java使用的是抢占式调度。
文章出处登录后可见!