Java基础——多线程

最新推荐文章于 2025-05-31 16:10:35 发布

北້໌ᮨ陌

最新推荐文章于 2025-05-31 16:10:35 发布

阅读量496

点赞数

分类专栏： java学习文章标签： java

本文链接：https://blog.youkuaiyun.com/qq_45907490/article/details/120001332

版权

java学习专栏收录该内容

8 篇文章

订阅专栏

多线程

一、线程与进程
二、线程调度
三、同步与异步&并发与并行
四、线程安全问题
五、公平锁与非公平锁
六、线程的三种创建方式
五、线程池 Executors

一、线程与进程

进程

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间线程

线程

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

二、线程调度

分时调度

所有线程轮流使用CPU使用权，平均分配每个线程占用CPU的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，
Java使用的为抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，
只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时
刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使
用率更高。

三、同步与异步&并发与并行

同步：排队执行，效率低但是安全。

异步：同时执行，效率高但是数据不安全。

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件同一时刻发生(同时发生)。

四、线程安全问题

解决方案:

(1)同步代码块

synchronized(锁对象){}

(2)同步方法

public synchronized boolean sale(){}

(3)显式锁

Lock l  =new ReentrantLock();
l.lock();
l.unlock();

五、公平锁与非公平锁

//fair参数为true，就是表示公平锁
Lock l  =new ReentrantLock(true);

六、线程的三种创建方式

(1)继承Thread

package com.test;

public class Demo {
    public static void main(String[] args) {
        //这里的代码就是一条新的执行路径
        //这个执行路径的出发方式。不是调用run方法，而是通过Thread对象的start()来启动任务。
        new Thread().start();
        for (int i = 0; i < 10; i++) {
            System.out.println("锄禾日当午"+i);
        }
    }
}
/*
运行结果:
锄禾日当午0
锄禾日当午1
锄禾日当午2
锄禾日当午3
锄禾日当午4
锄禾日当午5
锄禾日当午6
锄禾日当午7
锄禾日当午8
锄禾日当午9
*/

(2)实现Runnable

package com.test;

public class Demo {
    public static void main(String[] args) {
        //实现Runnable
        //1.    创建一个任务对象
        MyRunnable r = new MyRunnable();
        //2.    创建一个线程，并为其分配一个任务
        Thread t = new Thread();
        //3.    执行这个线程
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("疑是地上霜" + i);
        }
    }

    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            //线程的任务
            for (int i = 0; i < 10; i++) {
                System.out.println("窗前明月光" + i);
            }
        }
    }
}
/*
运行结果：
疑是地上霜1
疑是地上霜2
疑是地上霜3
疑是地上霜4
疑是地上霜5
疑是地上霜6
疑是地上霜7
疑是地上霜8
疑是地上霜9
*/

(3)带返回值的线程Callable

package com.test;

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

public class Demo {
    public static void main(String[] args) {
        Callable<Integer> c = new MyRunnable();
        FutureTask<Integer> task = new FutureTask<>(c);
        new Thread(task).start();
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            System.out.println(i);
        }
        }
    }

     class MyRunnable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                }
                System.out.println(i);
            }
            return 100;
        }
    }
/*
运行结果:
0
0
1
1
2
2
3
3
4
4
5
5
6
6
7
7
8
8
9
9
*/

五、线程池 Executors

（1）线程池的好处

降低资源消耗
提高响应速度
提高线程的可管理性

（2）Java中的四种线程池 ExcutorService

1、缓存线程池

执行流程：
1、判断线程是否存在空闲线程
2、存在则使用
3、不存在，则创建线程，并放入线程池，然后使用

package com.test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo {
    public static void main(String[] args) {
        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());
            }
        });
    }
}

/*
运行结果:
线程的名称:pool-1-thread-1
线程的名称:pool-1-thread-2
线程的名称:pool-1-thread-2
*/

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

执行流程：
1、判断线程池是否存在空闲线程
2、存在则使用
3、不存在空闲线程，且线程池未满的情况下，则创建线程，并放入线程池，然后使用
4、不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程。

package com.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        //向线程中加入新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
    }
}
/*
运行结果:
线程的名称:pool-1-thread-2
线程的名称:pool-1-thread-1
线程的名称:pool-1-thread-2
*/

3、单线程线程池

执行流程：
1、判断线程池的那个线程是否空闲
2、空闲则使用
3、不空闲，则等待池中的单个线程空闲后使用

package com.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo {
    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()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}
/*
运行结果:
pool-1-thread-1锄禾日当午
pool-1-thread-1锄禾日当午
pool-1-thread-1锄禾日当午
pool-1-thread-1锄禾日当午
*/

4、周期性任务定长线程池

执行流程:
1、判断线程池是否存在空间流程
2、存在则使用
3、不存在空闲线程，且线程池未满的情况下，则创建线程，并放入线程池，然后使用
4、不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程。

package com.test;

import java.util.Timer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Demo {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 1.定时执行一次
         * 参数1. 定时执行的任务
         * 参数2. 时长数字
         * 参数3。时长数字的时间单位，TimeUnit的常量指定
         */
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("锄禾日当午");
            }
        },5,TimeUnit.SECONDS);

        /**
         * 周期性执行任务
         * 参数1. 任务
         * 参数2. 延迟时长数字(第一次执行是在什么时间以后)
         * 参数3. 周期时长数字(每隔多久执行一次)
         * 参数4. 时常数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("汗滴禾下土");
            }
        },5,1,TimeUnit.SECONDS);
    }
}

/*
运行结果：
锄禾日当午
汗滴禾下土
汗滴禾下土
汗滴禾下土
汗滴禾下土
汗滴禾下土
汗滴禾下土
*/