java小白从入门到精通（基础十七）

1. 线程池

如果我们用前面学习的知识,要创建100个线程那么就得new100次

线程的创建是非常耗费资源和耗时的

1.1 线程池有什么用?

• 解决了系统频繁的创建线程的资源消耗

• 达到了线程对象的重用

• 线程池可以保障系统的安全

1.2 使用线程池创建线程

//创建单线程的线程池(借助jdk中给我们提供的工具类Executors)
ExecutorService executorService1 = Executors.newSingleThreadExecutor();
//创建固定大小的线程池
ExecutorService executorService2 = Executors.newFixedThreadPool(10);
//创建弹性伸缩的线程池
ExecutorService executorService3 = Executors.newCachedThreadPool();

1.3 使用线程池对象创建和执行线程

package com.uplooking.demo02;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
     

    public static void main(String[] args) {
     
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(8);
        //使用线程池对象执行线程
        executorService.execute(new Runnable() {
     
            @Override
            public void run() {
     
                while (true) {
     
                    System.out.println("线程1");
                }
            }
        });
        //执行任务(线程池会帮我们创建线程)
        executorService.execute(new Runnable() {
     
            @Override
            public void run() {
     
                while (true) {
     
                    System.out.println("线程2");
                }
            }
        });


        //关闭线程池(等待线程池中的线程执行完毕之后才会关闭线程池)
        //executorService.shutdown();

        //立刻关闭线程池(关闭的是等待状态线程池中的线程)
        //executorService.shutdownNow();
    }
}

1.4 创建延时任务的线程池

package com.uplooking.demo03;

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

public class Main {
     
    public static void main(String[] args) {
     
        //创建延时任务的线程池对象
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(8);
        scheduledExecutorService.schedule(new Runnable() {
     
            @Override
            public void run() {
     
                System.out.println("hello up");
            }
        }, 3000, TimeUnit.MILLISECONDS);

        //关闭线程池
        scheduledExecutorService.shutdown();
    }
}

2. 常用的线程池是哪个?

FixedThreadPool(n)

n到底为多少性能才能发挥到最好?

n为cpu的核数性能最优

3. 线程是不是创建的越多越好?

不是

对单核的cpu而言,只能并行的执行一个线程,

对于8核的cpu而言,只能最多并行执行8个线程

最多为cpu的核数就可以了

4. 使用多线程的好处与弊端

好处:

• 提升程序的执行效率

弊端:

• 资源有额外的占用
• 线程会造成数据安全性问题(线程安全性问题)

5. 线程安全性问题

线程安全问题: 多个线程同时(并行)操作同一个数据的时候出现的数据的安全性问题

5. 售票代码实现

5.1 线程安全性问题的讲解

5.2 解决线程的安全性问题

核心思想: 对多个线程操作(全局)共享变量的代码,只能同时让一个线程访问

给操作全局变量的代码加锁

5.2.1 加锁一定好吗?

凡是加锁,效率必然会受影响,我们问题是一定要解决的,我们能做的就是尽量提高效率;

6. java中的线程锁的分类

• 悲观锁
• 乐观锁
• 可重入锁
• 可选锁
• aqs锁
• …

7. java中的加锁的方式(面试几率极高)

• lock锁(手动挡): 锁的获取和释放都需要手动的进行
• **synchronized锁(自动挡)*锁的获取和释放都是(api)自动进行

8. Synchronized锁

8.1 同步(Synchronized)方法

锁对象: 调用当前(run)方法的对象

上面我们加的锁是属于: 悲观锁,而我们在实际的生产环境中,绝对要避免悲观锁的存在

同步方法的锁对象不能改变,只能是调用当前方法的对象

8.2 同步(Synchronized)代码块

同步代码快的锁对象可以自己任意定义,但是要保证有意义;

9. 可重入锁(面试高频问题)

上面这个代码是可以正常执行的,;那就说明同一个锁对象可能被同一个线程对象获取了两次;

同一个锁对象被获取两次,那么加锁毫无意义了;

上面的描述经过我刚才的分析发现是错误的;

9.1 锁的可重入性

​ 锁是可以被传递的

​ 在一个锁中调用另外一个锁的代码**,这两个锁是同一个锁**,那么锁是可以被传递的;

一般我们设计的优秀的锁,都要具有传递性

一般我们设计的优秀的锁,都要是可重入锁

10. Lock锁

相当于手动挡的车:锁的创建,获取和解锁都要自己来干;

好处: 拥有极高的自定义性

弊端: 对编程能力要求高

10.1 Lock锁的分类

• 读锁
• 写锁
• 可重入锁
  

11. 线程死锁

你中有我,我中有你

锁A中调用锁B,

同时

锁B调用锁A

互相处于永久的等待释放状态

12. 线程死锁代码实现

package com.uplooking.demo07;

public class Main {
     

    public static Object lockObjA = new Object();
    public static Object lockObjB = new Object();

    public static void main(String[] args) {
     
        RunnableA runnableA = new RunnableA();
        RunnableB runnableB = new RunnableB();

        new Thread(runnableA, "窗口A").start();
        new Thread(runnableB, "窗口B").start();

    }
}

class RunnableA implements Runnable {
     
    @Override
    public void run() {
     
        synchronized (Main.lockObjA) {
     
            System.out.println("lockObjA " + Thread.currentThread().getName());
            try {
     
                //避免直接获取到lockB这个锁
                Thread.sleep(2000);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            synchronized (Main.lockObjB) {
     
                System.out.println("lockObjB ");
            }
        }

    }
}


class RunnableB implements Runnable {
     
    @Override
    public void run() {
     
        synchronized (Main.lockObjB) {
     
            System.out.println("lockObjB " + Thread.currentThread().getName());
            try {
     
                Thread.sleep(2000);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            synchronized (Main.lockObjA) {
     
                System.out.println("lockObjA ");
            }
        }
    }
}

13. 死锁问题如何解决

通过sun公司提供的性能分析工具 jconsole来监测死锁,监测出来之后就可以修改死锁代码;

14. jvm内存中的栈

栈: 线程栈

• 每个线程都拥有自己的内存空间和资源,互不影响
• 栈中的数据是线程独占的,堆中的数据是线程共享的;
• 所以栈中定义的局部变量不存在线程安全性问题,因为是线程独占的,而堆中的数据存在线程安全性问题,因为堆的数据是线程共享的;

15. 多线程开发的注意问题

• 尽量使用线程池技术创建和管理线程
• 能不使用全局共享变量尽量不要使用
• 要是使用全局共享变量,并且多个线程同时写操作,解决线程安全问题,尽量不要使用悲观锁;
• 能使用synchronized尽量不要使用lock锁;