Java学习记录（多线程）
多线程
多线程
线程与进程
概念：
进程：
- 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间
线程：
- 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程
- 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程
线程调度：
分时调度：
- 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度：
- 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
- CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使用率更高。
同步与异步：
同步:
- 排队执行 , 效率低但是安全
异步:
- 同时执行 , 效率高但是数据不安全
并发与并行：
并发：
- 指两个或多个事件在同一个时间段内发生
并行：
- 指两个或多个事件在同一时刻发生（同时发生）
线程的实现
1.extends Thread
public class MyThread extends Thread {
//run方法就是线程要执行的任务方法
@Override
public void run() {
//这里的代码就是一条新的执行路径
//这个执行路径处罚方法不是通过调用run方法，而是通过调用Thread对象的start()方法启动，
for (int i = 0;i<10;i++){
System.out.println("A"+i);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThread t = new MyThread();
t.start();
for (int i = 0;i<10;i++){
System.out.println("B"+i);
}
}
}
B0 B1 B2 B3 B4 B5 A0 B6 A1 B7 A2 B8 A3 B9 A4 A5 A6 A7 A8 A9
2.implements Runnable
//1.创建一个任务对象
MyRunnable t1 = new MyRunnable();
//2.创建一个线程，并分配任务
Thread ts = new Thread(t1);
//3.执行线程
ts.start();
Runnable与Thread相比的优势：
1.通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程同时执行任务的情况
2.可以避免单继承所带来的局限性
3.任务与线程本身是分离的，提高了程序的健壮性
4.后续学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程
Thread
| 序号 | 变量和类型 | 方法 | 描述 |
|---|---|---|---|
| 1 | long | getId() | 返回此Thread的标识符 |
| 2 | String | getName() | 返回此线程的名称 |
| 3 | int | getPriority() | 返回此线程的优先级 |
| 4 | void | setPriority(int newPriority) | 更改此线程的优先级 |
| 5 | static void | sleep(long millis) | 导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性 |
| 6 | static void | sleep(long millis, int nanos) | 导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数加上指定的纳秒数，具体取决于系统定时器和调度程序的精度和准确性 |
获取进程名称
public class GetThreadName implements Runnable{
@Override
public void run() {
//获取线程名称
Thread.currentThread().getName();
}
}
Sleep
for (int i = 0;i<10;i++){
System.out.println(i);
//休眠时间(单位:毫秒)
Thread.sleep(1000);
}
线程中断
一个线程是一个独立的执行路径，他是否应该结束，应该有其自身决定
如果强制中断线程可能导致线程占用的资源得不到释放
//对线程进行标记，提示线程应该结束了
t1.interrupt();
static class Num implements Runnable {
@Override
public void run() {
for (int i = 0;i<10;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//对线程进行结束处理，释放线程占用的资源
System.out.println("Stop");
return;
}
}
}
}
守护线程
线程：分为用户线程和守护进程
用户进程：当一个进程不包含任何存活的用户进程时，进程结束
守护进程：守护用户进程当最后一个用户进程结束时，所有的守护线程自动死亡
//设置为守护线程
t1.setDaemon(true);
线程安全
线程不安全
static class Ticket implements Runnable{
private int count = 10;
@Override
public void run() {
while (count>0){
System.out.println("开始售票：");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println("余票："+count);
}
}
}
当票数下降到临界值（即为1）时，线程执行时可能出现时间片丢失的情况，这时其他线程就会执行代码，此时票数的值还是临界值，但实际上应该是小于临界值，这时就会引发线程不安全问题
线程安全
同步代码块（synchronized）：
synchronized给进程加一把锁，让进程执行的时候能排队执行
同步方法（synchronized）：
使用synchronized修饰方法，就能使方法在执行时排队执行
同步方法锁的是调用方法的对象，但是当用static修饰方法时，锁的对象就变成了 类名.class
显示锁：
显示锁 Lock 子类 ReentrantLock
公平锁和非公平锁：
公平锁就是所有的线程获得时间片的方式是先到先得
非公平锁就是线程获得时间片的方式是抢夺时间片
当创建显示锁时传入一个fair参数true就为公平锁
线程死锁
在一个已经产生锁的方法中调用另一个可能产生锁的方法就有可能产生死锁的可能
public class DeadlockDemo {
public static void main(String[] args) {
Culprit c = new Culprit();
Police p = new Police();
new MyThread(c,p).start();
c.say(p);
}
static class MyThread extends Thread{
private Culprit c;
private Police p;
public MyThread(Culprit culprit, Police police){
this.c = culprit;
this.p = police;
}
@Override
public void run() {
p.say(c);
}
}
static class Culprit{
public synchronized void say(Police p){
System.out.println("a");
}
public synchronized void fun(){
System.out.println("b");
}
}
static class Police{
public synchronized void say(Culprit c){
System.out.println("c");
}
public synchronized void fun(){
System.out.println("d");
}
}
}
多线程通信问题
| 序号 | 类型和变量 | 方法 | 描述 |
|---|---|---|---|
| 1 | void | notify() | 唤醒正在此对象监视器上等待的单个进程 |
| 2 | void | notifyAll() | 唤醒正在此对象监视器的所有进程 |
| 3 | void | wait() | 导致当前线程等待它被唤醒，通常是 通知 或 中断 |
| 4 | void | wait(long timeoutMillis) | 导致当前线程等待它被唤醒，通常是 通知 或 中断 ， 或者知道进过一定量的实时 |
| 5 | void | wait(long timeoutMillis, int nanos) | 导致当前线程等待它被唤醒，通常是 通知 或 中断 ，或者知道进过一定量的实时 |
生产者消费者问题
public class ProducerConsumer {
public static void main(String[] args) {
Food f = new Food();
new Cook(f).start();
new Waiter(f).start();
}
static class Cook extends Thread{
private Food f;
public Cook(Food f){
this.f = f ;
}
@Override
public void run() {
for (int i = 0;i<10;i++){
if (i%2 == 0){
f.setNameAndTaste("煎饼果子","香辣");
}else {
f.setNameAndTaste("驴脸蛋子","奥利给");
}
}
}
}
static class Waiter extends Thread{
private Food f;
public Waiter(Food f){
this.f = f ;
}
@Override
public void run() {
for (int i = 0;i<10;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
f.get();
}
}
}
static class Food {
static boolean flag = true;
private String name;
private String taste;
public void setNameAndTaste(String name, String taste){
if (flag) {
this.name = name;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.taste = taste;
flag = false;
this.notifyAll();
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void get(){
if (!flag) {
System.out.println("端走的菜是" + name + "，味道" + taste);
flag = true;
this.notifyAll();
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
线程的六种状态
NEW
尚未启动的线程处于此状态。
RUNNABLE
在Java虚拟机中执行的线程处于此状态。
BLOCKED
被阻塞等待监视器锁定的线程处于此状态。
WAITING
无限期等待另一个线程执行特定操作的线程处于此状态。
TIMED_WAITING
正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
TERMINATED
已退出的线程处于此状态
Callable
接口定义
//Callable接口
public interface Callable {
V call() throws Exception;
}
//Runnable接口
public interface Runnable {
public abstract void run();
}
Callable使用步骤
编写类实现Callable接口 , 实现call方法
class XXX implements Callable {
@Override
public call() throws Exception {
return T;
}
}
创建FutureTask对象 , 并传入第一步编写的Callable类对象
FutureTask future = new FutureTask<>(callable);
通过Thread,启动线程
new Thread(future).start();
Runnable 与 Callable的相同点
- 都是接口
- 都可以编写多线程程序
- 都采用Thread.start()启动线程
Runnable 与 Callable的不同点
- Runnable没有返回值；Callable可以返回执行结果
- Callable接口的call()允许抛出异常；Runnable的run()不能抛出
Callable获取返回值
- Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
线程池
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。
线程池的好处
降低资源消耗
提高响应速度
提高线程的可管理性
创建线程池
//创建缓存线程池
ExecutorService service = Executors.newCachedThreadPool();
//创建定长线程池
ExecutorService service = Executors.newFixedThreadPool(线程池长度);
//创建单线程线程池
ExecutorService service = Executors.newSingleThreadExecutor();
//创建周期性任务定长线程池
ScheduledExecutorService service = Executors.newScheduledThreadPool(线程池长度);
1.缓存线程池
缓存线程池.
(长度无限制)
执行流程:
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在,则创建线程 并放入线程池, 然后使用
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
Sou s = new Sou();
//向线程池中添加任务
service.execute(s);
service.execute(s);
service.execute(s);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
service.execute(s);
service.execute(s);
}
static class Sou implements Runnable{
static int count = 0;
Lock l = new ReentrantLock();
@Override
public void run() {
l.lock();
System.out.println(Thread.currentThread().getName()+"A"+count);
count++;
l.unlock();
}
}
pool-1-thread-2A0
pool-1-thread-1A1
pool-1-thread-3A2
pool-1-thread-3A3
pool-1-thread-3A4
2.定长线程池
定长线程池.
(长度是指定的数值)
执行流程
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(2);
Sou s = new Sou();
service.execute(s);
service.execute(s);
service.execute(s);
service.execute(s);
service.execute(s);
service.execute(s);
}
static class Sou implements Runnable{
static int count = 0;
Lock l = new ReentrantLock();
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"A"+count);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count++;
}
}
pool-1-thread-1A0
pool-1-thread-2A0
pool-1-thread-1A2
pool-1-thread-2A2
pool-1-thread-1A3
pool-1-thread-2A4
3.单线程线程池
效果与定长线程池 创建时传入数值1 效果一致.
单线程线程池.
执行流程:
- 判断线程池 的那个线程 是否空闲
- 空闲则使用
- 不空闲,则等待 池中的单个线程空闲后 使用
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor();
Sou s = new Sou();
service.execute(s);
service.execute(s);
service.execute(s);
service.execute(s);
}
static class Sou implements Runnable{
static int count = 0;
Lock l = new ReentrantLock();
@Override
public void run() {
l.lock();
System.out.println(Thread.currentThread().getName()+"A"+count);
count++;
l.unlock();
}
}
pool-1-thread-1A0
pool-1-thread-1A1
pool-1-thread-1A2
pool-1-thread-1A3
4.周期性任务定长线程池
public static void main(String[] args) {
周期任务 定长线程池.
执行流程:
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
周期性任务执行时:
- 定时执行, 当某个时机触发时, 自动执行某任务
public static void main(String[] args) {
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
SimpleDateFormat date = new SimpleDateFormat("HH:mm:ss:ms");
Sou s = new Sou();
/**
* 1.定时执行一次
* 参数1.执行的任务
* 参数2.执行的时长数字
* 参数3.时长数字的单位， TimeUnit的常量指定
*/
System.out.println(date.format(new Date()));
service.schedule(s,5,TimeUnit.SECONDS);
/**
*周期执行
* - 参数1. runnable类型的任务
* - 参数2. 时长数字(延迟执行的时长)
* - 参数3. 周期时长(每次执行的间隔时间)
* - 参数4. 时长数字的单位
*/
service.scheduleAtFixedRate(s,5,5,TimeUnit.SECONDS);
}
static class Sou implements Runnable{
SimpleDateFormat date = new SimpleDateFormat("HH:mm:ss:ms");
static int count = 0;
Lock l = new ReentrantLock();
@Override
public void run() {
l.lock();
System.out.println(date.format(new Date()));
System.out.println(Thread.currentThread().getName()+"A"+count);
count++;
l.unlock();
}
}
Lambda表达式
public static void main(String[] args) {
//Lambda表达式
//(参数) -> {方法体}
new Thread(() -> System.out.println("A")).start();
print((int x, int y) ->{
return x+y;
},100,200);
}
private static void print(MyNum m, int x, int y) {
int sum = m.sum(x,y);
System.out.println(sum);
}
static interface MyNum{
int sum(int x, int y);
}