背景
单线程只使用一个CPU完成多个任务(调用多个方法),肯定比用多个线程完成的总时间更短,为什么要使用多线程呢?
答:1.提高应用程序的响应,增强用户体验;2.提高计算机系统CPU的利用率。
进程,线程;并发,并行的概念:
2. 线程创建的三种方式进程:程序的一次执行过程,是一个动态的过程。进程作为资源分配的最小单位,一个进程至少拥有一个线程;
线程:线程堆空间是共享的,栈空间相互独立。线程是CPU调度的最小单位 ;
并发:一个CPU同时执行多个任务;
并行:多个CPU同时执行多个任务;
进程运行过程中的三种基本状态:(a)就绪状态(Ready),(b)运行状态(Running),(c)阻塞状态(Blocked)。
代码层面的状态Thread.State
方式一:继承Thread类
方式二:实现Runnable接口
方式三:JDK1.5新增:实现Callable接口
结合代码分析三种线程创建的优缺点:
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//线程创建的三种方式
public class ThreadTest {
public static void main(String[] args) {
//------------------------方式1-----------------------------------------
//new一个新线程对象
MyThread myThread = new MyThread();
//调用start方法启动线程,(执行的还是run方法)
myThread.start();
//------------------------方式1-----------------------------------------
//------------------------方式2-----------------------------------------
//------------------方式2------------第1种-----------
Runnable target = new MyRunnable();
Thread t = new Thread(target);
t.start();
//------------------方式2------------第2种------------
Runnable t2 = new Runnable() {
@Override
public void run() {
for(int i = 0; i < 4; i++){
System.out.println("子线程3输出:" + i);
}
}
};
Thread thread = new Thread(t2);
thread.start();
//------------------------方式2-----------------------------------------
//------------------------方式3-----------------------------------------
//创建Callable对象
Callable call = new MyCallable(12);
//把Callable对象交给FutureTask对象
FutureTask f1 = new FutureTask<>(call);
//交给线程处理
Thread t4 = new Thread(f1);
t4.start();
//通过get方法得到线程对象结果
try {
System.out.println(f1.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
//------------------------方式3-----------------------------------------
for(int i = 0; i < 4; i++){
System.out.println("主线程输出:" + i);
}
}
}
class MyThread extends Thread{
@Override //重写run方法
public void run() {
super.run();
for(int i = 0; i < 4; i++){
System.out.println("子线程1输出:" + i);
}
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
for(int i = 0; i < 4; i++){
System.out.println("子线程2输出:" + i);
}
}
}
class MyCallable implements Callable{
private int n;
public MyCallable(int n ){
this.n = n;
}
@Override
public String call() throws Exception {
int sum = 0;
for(int i = 1; i < n; i++){
sum += i;
}
return "子线程执行结果是:" + sum;
}
}
3. 线程同步
线程同步是为了解决什么问题?
在多线程操作中,多个线程可能同时处理同一个资源,特别是对统一资源进行修改的时候,就容易出现线程安全问题。
线程同步解决线程安全的思想:对共享资源进行加锁。
作用:把出现线程安全问题的核心代码给上锁。
原理:每次只能一个线程进入,执行完毕后自动解锁,其他线程才可以进来执行。
synchronized (同步锁对象){
操作共享资源的代码(核心代码)
}
锁对象的规范要求:
建议使用共享资源作为锁对象;
对于实例方法建议使用this作为锁对象;
对于静态方法建议使用字节码(类名.class)对象作为锁对象;
3.2 同步方法
作用:把出现线程安全问题的核心方法给上锁。原理同上。
修饰符 synchronized 返回值类型(形参列表){
操作共享资源的代码(核心代码)
}
关于synchronized的知识补充:
synchronized在同步代码块中是通过明确的monitorenter和monitorexit指令实现;
synchronized在同步方法中是通过ACC_SYNCHRONIZED标志来隐式实现。
Java早期版本中,synchronized属于重量级锁,因为挂起或者唤醒一个线程,都需要操作系统帮忙完成,而操作系统实现线程之间的切换时需要从用户态转换成内核态,这个转换花费时间比较长,这也是早期synchronized效率低的原因;
JDK1.6之后,synchronized关键字底层的优化,出现了自旋锁、偏向锁、轻量级锁等技术来减少锁操作的开销。
锁的四种状态:无锁——》偏向锁——》轻量级锁——》重量级锁,注意锁升级的过程是不可逆的。
偏向锁:总是由同一个线程多次获取,那么此时就是偏向锁;
轻量级锁:轻量级锁由偏向锁升级而来,当存在第二个线程申请同一个锁对象时,偏向锁就会立即升级为轻量级锁。注意这里第二个线程只是申请锁,不存在两个线程同时竞争锁,可以是一前一后地交替执行同步块;
重量级锁:由轻量级锁升级而来,当同一时间,有多个线程申请同一个锁对象,轻量级锁就会被升级为重量级锁;
CAS:compare and swap,又称为无锁或者自旋锁。
大概意思是当你获取当前数值为1,最后输出和1比较,相同就不用加锁。
ABA问题:线程a把1改成3,线程2有把3改回成1,最终a还是1,但是在第一步中a等于3;
如何在项目中使用synchronized
synchronized关键字主要的三种使用方式:
1、修饰实例方法:作用于当前对象实例加锁,进入同步代码前要获得当前对象实例的锁;
2、修饰静态方法:作用于当前类对象加锁,进入同步代码前要获得当前类对象的锁。当一个线程A调用实例对象的非静态synchronized方法,而线程B调用这个实例对象所属类的静态synchronized方法,是允许的,不会发生互斥现象,因为访问静态synchronized方法占用的锁是当前类的锁,而访问非静态synchronized方法占用的锁是当前实例对象的锁;
3、修饰代码块:指定加锁对象,对给定对象加锁,进入同步代码块前要获得给定对象的锁。synchronized(this){代码块} 也是锁定当前对象。synchronized关键字加到static静态方法和synchronized(class)代码块上都是给Class类上锁。
class Test1{
private int i = 0;
private static int j = 0;
private final SynchronizedTest aa = new SynchronizedTest();
//修饰实例方法: 锁对当前对象(this) flags: ACC_PUBLIC,ACC_SYNCHRONIZED
public synchronized void add1(){
i++;
}
//对静态方法加锁: 锁对当前类的字节码文件(Test1.class) 静态方法属于类,不属于对象。 flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
public synchronized static void add2(){
j++;
}
//修饰代码块,指定加锁对象 flags: ACC_PUBLIC; monitorenter monitorexit
public void method(){
synchronized (Test1.class){
System.out.println("11");
}
synchronized (aa){
System.out.println("22");
}
}
}
可以通过在终端输入指令javap -p -v -v Test1.class查看到,同步代码块基于monitorenter、monitorexit实现,而同步方法基于ACC_SYNCHRONIZED标识实现。
// final修饰后,锁对象是唯一和不可替换的。
final Lock lock = new ReentrantLock();
lock.lock(); //上锁
try{
}finally{
lock.unlock(); //解锁
}
4. 线程的死锁
死锁的解释:
当不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁。出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续。
生产者消费者案例代码(解决死锁的一个案例):
4. 线程池https://blog.csdn.net/qq_41894176/article/details/123829040
什么是线程池?为什么要使用线程池?
1、线程池就是一个可以复用线程的技术。
2、如果用户没发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能。
谁代表线程池?
JDK1.5起提供代表线程池的接口:ExecutorService
怎么得到线程池对象?
方式一:使用ExecutorService的实现类ThreadPoolExecutor创建一个线程池对象;
方式二:使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象;
ThreadPoolExecutor构造器的参数说明:
临时线程什么时候创建?
新任务提交是发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程。
什么时候开始拒绝任务?
核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝。
使用ThreadPoolExecutor线程池处理Runnable和Callable
import java.util.concurrent.*;
public class ThreadPoolTest {
public static void main(String[] args){
//1.创建线程池对象
ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
//
// //-----------------------------Runnable--------------------------
// //2.将任务交给线程池处理
// Runnable target = new RunnableMy();
// pool.execute(target);
// pool.execute(target);
// pool.execute(target);
//
// //5
// pool.execute(target);
// pool.execute(target);
// pool.execute(target);
// pool.execute(target);
// pool.execute(target);
//
// //创建临时线程 [当等待线程超过5个时,就会创建临时线程] new ArrayBlockingQueue<>(5)
// pool.execute(target);
// pool.execute(target);
//
// //当线程数超过5个时,会报错
// pool.execute(target);
//
// //关闭线程池(一般不会使用)
pool.shutdown(); //立即关闭,即使任务没有完成,会丢失任务!!
// //-----------------------------Runnable--------------------------
//-----------------------------Collable--------------------------
Future f1 = pool.submit(new CallableMy(10));
Future f2 = pool.submit(new CallableMy(5));
Future f3 = pool.submit(new CallableMy(100));
try {
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
//-----------------------------Collable--------------------------
}
}
class RunnableMy implements Runnable{
@Override
public void run() {
for(int i = 0; i < 3; i++){
System.out.println("Runnable:" + i + "____" + Thread.currentThread().getName());
}
try {
System.out.println("线程进入休眠--->" + Thread.currentThread().getName());
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class CallableMy implements Callable{
private int n;
public CallableMy(int n ){
this.n = n;
}
@Override
public String call() throws Exception {
int sum = 0;
for(int i = 1; i < n; i++){
sum += i;
}
System.out.println(Thread.currentThread().getName() + ":" + "Callable");
return "子线程执行结果是:" + sum;
}
}
——————————————————
未完待续


