多线程技术

最新推荐文章于 2023-11-02 10:44:11 发布

xd渴望飞翔

最新推荐文章于 2023-11-02 10:44:11 发布

阅读量243

点赞数

CC 4.0 BY-SA版权

文章标签： java 多线程

本文链接：https://blog.youkuaiyun.com/qq_43498836/article/details/106844648

文章目录

线程Thread创建

继承Thread类

//继承Thread的匿名内部类
new Thread() {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread匿名内部类" + i);
        }
    }
}.start();

实现Runnable接口

public static void main(String[] args) {
    //创建一个线程任务
    MyRunnable mr = new MyRunnable();
    //创建一个线程
    Thread t = new Thread(mr);
    //启动线程
    t.start();
}

public class MyRunnable implements Runnable{
    @Override
    //给线程执行的任务
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("线程任务MyRunnable" + i);
        }
    }
}

实现有返回值的Callable接口

特点: 返回此线程完成的结果给主线程, 可以让主线程等待此线程完成的结果, 再继续主线程

创建Callable对象
创建FutureTask对象, 传入Callable对象
创建线程, 传入FutureTask对象

FutureTask类
- 构造方法:
  - FutureTask(Callable callable)
- 常用方法:
  - public V get(); //让主线程等待此线程任务返回的结果
  - public V get(long timeout, TimeUnit unit) //若主线程等待超过timeout时间, 则放弃结果继续执行

public static void main(String[] args) throws ExecutionException, InterruptedException {
    //创建Callable对象
    Callable<String> call = new MyCallable();
    //创建任务对象
    FutureTask<String> task = new FutureTask<>(call);
    
    //利用Lambda表达式创建Callable对象并传入FutureTask中
    FutureTask<String> task1 = new FutureTask<>(() -> {
        Scanner input = new Scanner(System.in);
        System.out.print("我是谁:");
        return input.nextLine();
    });
    
    //创建线程
    new Thread(task).start();
    String text = task.get();//主线程等待返回结果
    System.out.println(text);
    
    new Thread(task1).start();
    String text1 = task1.get();//主线程等待返回结果
    System.out.println(text1);
}
//实现Callable类
class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        Scanner input = new Scanner(System.in);
        System.out.print("你是谁:");
        return input.nextLine();
    }
}

线程Thread类

构造方法

Thread()
Thread(String name) //设置线程名称
Thread(Runnable target) //传入线程任务
Thread(Runnable target, String name) //传入线程任务, 和设置线程名称

常用方法

String getName() //获取线程名称

//标记此线程为daemonc线程(守护线程)或用户线程 on为true:守护线程

public final void setDaemon(boolean on)
public static void sleep(long millis) //休眠正常执行的线程指定毫秒数
public static void sleep(long millis, int nanos) //休眠正常执行的线程指定毫秒数和纳秒数

//更改此线程优先级

public final void setPriority(int newPriority)

变量和类型	字段	描述
`static int`	`MAX_PRIORITY`	线程可以拥有的最大优先级。
`static int`	`MIN_PRIORITY`	线程可以拥有的最低优先级。
`static int`	`NORM_PRIORITY`	分配给线程的默认优先级。

static Thread currentThread() //返回当前正在指向的线程对象

线程的中断

public void interrupt() //标记线程中断

当线程在进行以下操作时, 被标记线程中断，会抛出异常InterruptedException :

Object方法：
- wait()； wait(long); wait(long, int);
Thread方法:
- sleep(long);
- interrupt();
- interrupted();

我们可以通过try catch异常处理上述函数,

在catch块中让run()方法return来中断线程, 同时处理一些释放资源后事

守护线程 (线程的生命周期)

线程分类：守护线程和用户线程

区别：

用户线程：当一个进程不包含任何存活的用户线程时，进程结束

守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。

设置守护线程的方法：

在启动线程前设置，setDaemon(true)

线程安全/线程的同步机制（加锁）

一段同步代码(被synchronized修饰的代码）被一个线程执行之前，他要先拿到执行这段代码的权限，在 java里边就是拿到某个同步对象的锁（一个对象只有一把锁）；如果这个时候同步对象的锁被其他线程拿走了，他（这个线程）就只能等了（线程阻塞在锁池等待队列中）。取到锁后，他就开始执行同步代码；线程执行完同步代码后马上就把锁还给同步对象，其他在锁池中等待的某个线程就可以拿到锁执行同步代码了。这样就保证了同步代码在统一时刻只有一个线程在执行。

隐式锁(Synchronized)与显示锁(Lock子类ReentrantLock)

用法:

隐式锁: (非公平锁)
- 同步代码块: synchroniced(锁对象){ }
- 同步方法: synchroniced修饰方法
显示锁: (有参构造 : 默认非公平锁false|公平锁true)
- 创建锁对象 Lock l = new ReentrantLock(boolean fair);
// lock与unlock之间为要加锁保证线程安全的代码
- 获得锁(上锁) l.lock();
- 释放锁(解锁) l.unlock(); //释放锁放在finally代码块中，保证出现异常也能释放锁

区别	隐式锁Synchronized	显示锁ReentrantLock
出身不同	Java中的关键字，JVM层面的锁	Jdk5以后定义好的Lock类
使用方式不同	系统自动获得锁和释放锁	lock与unlock方法手动获得锁和释放锁
等待是否可中断	不可中断，除非抛出异常	可以调用函数手动中断
是否公平锁	非公平锁	非公平锁\|公平锁

线程死锁

根源解决: 不要在会产生锁的方法中调用另一个会产生锁的方法

线程通讯

控制线程的执行依次, 把线程联系起来
wait 和 notify

线程池

代码执行流程:
//创建相应的线程池
ExecutorService service = Executors.相应的线程();
//指挥线程池执行Runnable线程任务
service.execute(Runnable线程任务);

缓存线程池(长度无限制)

创建方法: ExecutorService service = Executors.newCachedThreadPool();

任务加入后的执行流程:

判断线程池是否存在空闲线程
存在则使用
不存在, 则创建线程并放入线程池, 然后使用

public static void main(String[] args) {
    //缓冲线程池CachedThreadPool
    ExecutorService service = Executors.newCachedThreadPool();
    //指挥线程池执行新的任务
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+" 小鸡炖蘑菇");
        }
    });
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+" 小鸡炖蘑菇");
        }
    });
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+" 小鸡炖蘑菇");
        }
    });
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+" 使用缓冲池中已存在的空闲线程");
        }
    });
}

定长线程池 (长度是指定的数值)

创建方法: ExecutorService service = Executors.newFixedThreadPool(int nThreads); //nThreads指定长度

任务加入后的执行流程:

判断线程池中是否存在空闲线程
存在则使用
不存在空闲线程, 且线程池未满的情况下, 则创建线程并放入线程池, 然后使用
不存在空闲线程, 且线程池已满的情况下, 则等待线程池存在空闲线程

public static void main(String[] args) {
    //创建定长线程池, 参数为指定的线程个数
    ExecutorService service = Executors.newFixedThreadPool(2);
    //指挥线程池执行任务
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 长沙臭豆腐");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 长沙臭豆腐");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 等待线程池中存在空闲线程");
        }
    });
}

单线程线程池

创建方法: ExecutorService service = Executors.newSingleThreadExecutor();

任务加入后的执行流程:

判断线程池的那个线程是否空闲
空闲则使用
不空闲, 则等待池中的单个线程空闲后使用

public static void main(String[] args) {
    ExecutorService service = Executors.newSingleThreadExecutor();
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 武汉热干面");
        }
    });
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 武汉热干面");
        }
    });
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 武汉热干面");
        }
    });
}

周期定长线程池

创建方法: ScheduledExecutorService service Executors.ScheduledThreadPool(int corePoolSize)

执行线程任务方法:

service.schedule( ) //定时执行一次任务
- 参数1: 定时执行的任务
- 参数2: 时长数字
- 参数3: 时长数字的时间单位, TimeUnit的常量指定
service.scheduleAtFixedRate() //周期性执行任务
- 参数1: 任务
- 参数2: 延迟时长数字(第一次执行在什么时间以后)
- 参数3: 周期时长数字(每隔多久执行一次)
- 参数4: 时长数字的单位

任务加入后的执行流程:

判断线程池中是否存在空闲线程
存在则使用
不存在空闲线程, 且线程池未满的情况下, 则创建线程并放入线程池, 然后使用
不存在空闲线程, 且线程池已满的情况下, 则等待线程池存在空闲线程

public static void main(String[] args) {
    //创建周期定长线程池
    ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
    //定时执行一次任务
    service.schedule(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "定时执行一次任务");
        }
    }, 5, TimeUnit.SECONDS);//五秒后执行

    //周期性执行任务
    service.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "周期性执行任务");
        }
    }, 5, 1, TimeUnit.SECONDS);//五秒后执行第一次, 之后没1秒执行一次
}