java

最新推荐文章于 2025-05-04 12:14:29 发布

乘物游心0823

最新推荐文章于 2025-05-04 12:14:29 发布

阅读量129

点赞数

分类专栏： java

本文链接：https://blog.youkuaiyun.com/lpq374606827/article/details/87997474

版权

java 专栏收录该内容

31 篇文章

订阅专栏

一. Java多线程

1.什么是线程?

线程是操作系统能够进行调度的最小单位.一个进程包含多个线程,每个线程执行不同的任务.不同的进程使用不同的内存,同一个进程中的线程共享一片内存空间.

2.为什么需要线程?

一般我们启动一个程序就是启动一个进程,程序执行过程中由于程序控制范围之外的某些条件导致程序堵塞,程序此时只能中止;使用线程时,我们在该进程中创建多个线程,每个线程执行不同的任务,当由于某些外在条件导致某个线程堵塞时,其他线程仍然可以执行,不会导致程序中止.java中的线程机制是抢占式的,调度机会周期性的中断线程,将上下文切换到另外一个线程继续执行,使得每个线程都有时间去执行任务.

3.如何使用线程?

1)创建任务,实现runnable或者callable接口

class Cnt extends Thread{
    public void run(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        };
        System.out.println("Cnt thread is running!");
    }
}
class Cnt2 implements Runnable{
    @Override
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Cnt2 thread is running!");
    }
}

2)将任务添加到线程中执行;

一种方法是显示创建Thread,调用start()方法创建线程执行任务;

public class ThreadTest {
    public static void main(String[] args){
        Cnt2 cnt2=new Cnt2();
        new Thread(cnt2).start();
        System.out.println("Main Method!");
    }
}

一种方法是使用executor来创建CachedThreadPool/FixedThreadPool/SingleThreadPool来执行任务;

public class ThreadTest {
    public static void main(String[] args){
        Cnt2 cnt2=new Cnt2();
        ExecutorService exec= Executors.newCachedThreadPool();
        exec.execute(cnt2);
        exec.shutdown();
        System.out.println("Main Method!");
    }
}

3)创建有返回结果的任务需要实现Callable<T>接口,返回Future<T>结果

import java.util.ArrayList;
import java.util.concurrent.*;

public class CallableTest {
    public static void main(String[] args){
        ExecutorService exec= Executors.newCachedThreadPool();
        ArrayList<Future<String>> res=new ArrayList<>();
        for(int i=0;i<10;i++){
            res.add(exec.submit(new TaskWithResult()));
        }
        for(Future<String> fs:res){
            try {
                System.out.println(fs.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }finally {
                if(!exec.isShutdown()){
                    exec.shutdown();
                }
            }
        }
    }
}

class TaskWithResult implements Callable<String> {
    private static int id=0;
    private final int cnt=id++;
    @Override
    public String call() throws Exception {

        return "TaksWithResult-"+cnt;
    }
}

4.多线程互斥Mutext

保证多线程的互斥性有两种方法:synchronized内置锁或ReentrantLock显示锁;

为什么需要ReentrantLock?

1)RentrantLock使用时可以显示锁定和释放锁,在释放锁时可以有其他的控制;

2)Lock.tryLock()可以尝试获取锁,当获取不到锁时可以执行其他的操作,而不是一直等待;

代码如下:

public class Task implements Runnable{
  private Lock lock=new ReentrantLock();
  private int counter=0;
  @Override
  public void run() {
  boolean captured=false;
captured=lock.tryLock();
  try{
  if(captured){
  counter++;
System.out.println(counter+" "+captured);
}else{
System.out.println("Not captured!");
}
}finally{
  if(captured) lock.unlock();
}
}
}

public class BasicThread{
  public static void main(String[] args){
Task t=new Task();
  for(int i=0;i<10;i++){
  new Thread(t).start();
}
}
}
输出:
1 true
Not captured!
2 true
3 true
Not captured!
4 true
5 true
6 true
7 true
8 true

可见,10个线程中有两个没有获取到锁,此时仍然会执行其后的语句

5.Volatile关键字

Volatile关键字用来修饰成员变量,作用是保证所修饰成员的可见性.可见性指在一个线程中修改的值,在其他线程中立即可以看到修改后的值.除了Volatile关键字,Synchronized和ReentrantLock也可以保证同步方法或同步块中内容的可见性.

private int i1; public int geti1(){return i1;}

volatile private i1; public int geti1{return i1;}

private int i1; public synchronized int geti1{return i1;}

第一种方法中获取的是当前线程中的副本,不一定是最新值;

第二种方法中获取的是主存中的值,因为volatile修饰的变量不会存在副本;

第三种方法中获取的是当前线程中的副本,但是synchronized关键字保证了主存和副本的同步;

private int i1; public void seti1(int v){ i1=v;}

volatile private i1; public void seti1(int v){ i1=v;}

private int i1; public void synchronized seti1(int v){ i1=v;}

第一种方法更新当前线程中的副本,其他线程不一定能立刻读取最新值;

第二种方法更新主存中的值,其他线程可以立马读取到;

第三种方法更新当前线程中的副本,但是synchronized关键字保证了将最新值更新到主存中,同时从主存读取最新值.

Volatile不能保证互斥,如下代码中,当有多个线程执行时,列表中元素的数量可能会超过100

public class VolatileTest implements Runnable{

volatile private int count=0;

ArrayList<Integer> list=new ArrayList<Integer>();

@Override

public void run() {

if(count<1000){

list.add(1);

count++;

}

6.线程协作

1)wait() notify() notifyAll()

2)condition

7.什么是死锁?如何避免死锁?

死锁指多个线程因竞争资源导致互相等待的僵局,若无外力作用,这些线程都无法继续执行.例如A线程锁定资源1,等待资源2,B线程锁定资源2,等待资源1,此时二者造成死锁;

避免死锁的技术:

1)按照相同的顺序加锁;

2)线程加锁时加上一定的时限,超过时限放弃对锁的请求,并释放占有的锁;

3)死锁检测,每当一个线程获得锁时,会在线程和锁相关的数据结构中进行记录,当线程申请锁时,也会进行相应的记录.当某线程申请锁失败时,会遍历锁的关系图,查看该锁是否已经被某线程占用,同时该线程正在申请的锁被自己占用,如果有便发生了死锁.有时,可能锁的关系图比较复杂,涉及多个线程造成死锁.

当检测到死锁发生时,一个可行的方法是释放所有锁,回退,等待一段随机的时间后重试;一个更好的方法是给这些线程设置优先级(或者随机设置优先级),让一个或几个线程回退,其他的线程继续等待;

8.什么是活锁?如何避免?

活锁指任务的执行没有被阻塞,由于某些条件没有满足,导致一直重复尝试,失败,尝试,失败.两个线程发生某些条件的碰撞之后重新执行,再次尝试后依然发生碰撞,长此下去就会发生活锁.

解决活锁的方法:

当检测到冲突时,暂停随机的一段时间后重试,将减小再次冲突的可能性.

9.什么是竞态条件?

如果程序运行顺序的改变会影响最终结果,这就是一个竞态条件.

在多线程环境下经常会存在竞态条件,如

public class ObjFactory {

private Obj instance;

public Obj getInstance(){

if(instance == null){

instance = new Obj();

}

return instance;

}

如果线程A,B同时执行getInstance方法,可能出现线程A B两次创建instance的情况;

解决方法:采用同步,创建同步方法或同步块

10.线程池的应用场景?优点?java线程池有哪几种以及相应的应用场景?线程池如何调优?

1)应用场景

需要处理的任务数量多,且单个任务的处理时间短;

2)优点

当任务数量多时,频繁的创建和销毁线程将会耗费系统的资源,另外jvm中存在创建过多的活动线程也会消耗大量的内存.线程池中的线程执行任务结束后可以重用而不是销毁,减小线程创建和销毁的开销,另外线程池可以设置线程数量的阈值,线程数量超过阈值时,后续任务将一直等待.防止产生过多的线程;

3)Java中的线程使用Executors创建,下图展示了线程池的结构

newCachedThreadPool 根据需要创建新的线程,以前创建的空闲线程可以重用,如果没有可用的则重新创建.该线程池没有设置线程数量的上限,使用时一定要小心;
newFixedThreadPool 固定线程数量的线程池,当任务数量超过线程数量时,将在线程池队列中等待
newScheduledThreadPool 创建一个线程池,可以在给定的时间延迟后执行任务或者定期执行
newSingleThreadPool 使用单个worker线程来执行任务,多个任务按照提交的顺序依次执行

4)线程池调优