多线程
多线程和线程池
什么是进程
进程是指运行中的应用程序，每个进程都有自己独立的地址空间(内存空间)，比如用户点击桌面的IE浏览器，就启动了一个进程，操作系统就会为该进程分配独立的地址空间。当用户再次点击左面的IE浏览器，又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。目前操作系统都支持多进程。
要点：用户每启动一个进程，操作系统就会为该进程分配一个独立的内存空间。
什么是线程
所谓线程，就是进程中一个实体，是被系统独立调度和分派的基本单位，线程本身不具有系统资源的调度权，仅仅拥有一点点用于在系统中运行所需的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。
一个线程可以创建和撤销其他的线程，同一进程中的多个线程之间可以并发执行，线程有就绪、阻塞、运行三种基本状态。
image.png
关于阻塞状态有以下三个
等待阻塞：执行wait()方法等待，由notify()或notifyAll()唤醒
同步阻塞:使用同步锁synchronized上锁
其他阻塞:执行sleep()或join()方法，或者发出了I/O请求时
线程的wait阻塞
Wait()方法是让线程释放对象锁，让让其他线程拿到锁之后去优先执行，当其他线程唤醒wait()中的线程或者拿到对象锁的线程执行完释放了对象锁之后，wait（）中的线程才会再次拿到对象锁从而执行。
线程的sleep阻塞
Sleep()方法是让线程睡眠，此时并没有释放对象锁，其他想要拿到睡眠线程的对象锁的线程也就拿不到相应的对象锁，从而不能抢在他前面执行。
多线程的安全问题
多个线程之间为什么会出现不安全
线程随机性原理，线程会被CPU随机切换，而线程访问的资源如果是堆或者方法取得资源的话，那么每个线程都可以改变这个数据，外加上线程额执行会被CPU随机切换。
多线程中对同步锁的使用
· 解决线程安全问题
①使用synchronized同步锁的引用
②使用对象锁(对当前对象进行加锁)
③synchronized锁多对象
多线程案例
1.我锁住了一个方法，当我执行了这个方法，其他方法能够执行这个方法么？
能
2.我锁的是这个对象呢？
获得当前对象锁的线程，在调用加锁的方法，不会阻塞；
调用该对象普通方法(既没有同步的方法)，不会阻塞；
既没有获得锁，调用的又是同步方法或代码块，会被阻塞。
3.在类中有两个对象，我对class加锁，我对class中的一个对象进行访问，其他线程能够访问另一个对象么？
不能，锁住整个class时，锁只能在方法执行后备释放才能执行其他方法或本方法，因为当前处于被锁定的范围中。
这里要注意，锁住class和锁住this是不同的，锁住this时类中的其他对象或方法可以被另一条线程使用，而锁住class时是不行的。、
什么是线程池？怎么使用？
线程池
线程池是一种多线程处理方法，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程，每个线程使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程处于空闲状态，线程池将会调度一个任务给它。如果所有线程都始终保持繁忙，但将任务放入到一个队列总，则线程池将在过一段时间后创建另一个辅助线程，但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。
线程池的工作原理
大佬文章带你解密：https://www.cnblogs.com/easycloud/p/3726089.html
线程池的参数有哪些？
1.corePoolSize:核心线程数
2.queueCapacity:任务队列容量(阻塞队列)
3.maxPoolSize：最大线程数
4.keepAliveTime:线程空闲时间
5.allowCoreThreadTimeOut:允许核心线程超时
6.rejectedExecutionHandler:任务拒绝处理器
队列
线程池的队列长度是无限大的，但是在实际生产环境下，当请求速度远大于处理速度时，队列的无限假如会造成资源耗尽，服务宕掉。
线程被释放后会被杀掉？
不会，会回到池子中，等待线程池的再次调度。
知道线程数达到最大值后，会发生什么事么？
剩下的请求任务会进入等待队列
线程池在实际开发项目中的使用：
①在执行消息入库的时候需要线程池，使用通用线程池，用于异步执行写操作不影响主程序
②在上传图片的时候，后台服务器是不支持多张图片上传的，利用线程池可以进行多张图片上传，从而减少上传的时间。
https://blog.csdn.net/androidstarjack/article/details/81124183
常用的线程池有4种
1.newCachedThreadPool----创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
2.newFixedThreadPool----创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。
3.newSingleThreadExecutor----创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO，LIFO,优先级)执行
FIFO:先进先出
LIFO:后进先出
4.newSchedule ThreadPool----创建一个定长的线程池，而且支持定时的以及周期性的任务执行。
线程池案例链接地址-------https://www.cnblogs.com/aaron911/p/6213808.html
线程池中的数据库连接池，它有什么好处？
数据库连接池负责分配，管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。
原因：数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现的尤为突出，对数据库连接的管理显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。
创建多线程方式
1.线程是什么？
线程被称为轻量级进程，是程序执行的最小单位，它是指在程序执行过程中，能够执行代码的一个执行单位。每个程序都至少有一个线程，也就是程序本身
2.线程状态
Java语言自定义了5种线程状态，在任意一个时间点，一个线程只能有且只有其中一个状态
①新建(new):创建后尚未启动的线程处于这种状态
②运行(Runnable):Runnable包括了操作系统线程状态得我Running和Ready，也就是处于此线程状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间。
③等待(Waiting)：处于这种状态的线程不会被分配CPU执行时间。等待状态又分为无期限等待和有期限等待，处于无期限等待的线程需要被其他线程显示地唤醒，没有设置Timeout参数的Object.wait()、没有设置Timeout参数的Thread.join()方法都会使线程进入无限期等待状态；有限期等待状态无须等待被其他线程显示地唤醒，在一定时间之后它们会由系统自动唤醒，Thread.sleep()、设置了Timeout参数的Object.wait()、设置了Timeout参数的Thread.join()方法都会使线程进入有限期等待状态。
④阻塞(Blocked):线程被阻塞了，"阻塞状态"与“等待状态”的区别是：“阻塞状态”在等待着获取到一个排他锁，这个时间将在另外一个线程放弃这个锁的时候发生；而"等待状态"则是在等待一段时间或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将进入这种状态。
⑤结束(Terminated):已终止线程的线程状态，线程已经结束执行。
下图是5种状态转换图：
image.png
线程同步方法
线程有4种同步方法：wait()、sleep()、notify()、notifyAll()
wait()：使线程处于一种等待状态，释放所持有的的对象锁。
sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用它时要捕获InterruptedException异常，不释放对象锁。
notify()：唤醒一个正在等待状态的线程。注意调用此方法时，并不能确切知道唤醒的是哪一个等待状态的线程，是由JVM来决定唤醒哪个线程，不是由线程优先级决定的。
notifyAll()：唤醒所有等待状态的线程，注意并不是给所有唤醒线程一个对象锁，而是让它们竞争。
创建线程的方式
在JDK1.5之前，创建线程就只有两种方式，即继承java.lang.Thread类和实现java.lang.Runnable接口；而在JDK1.5以后，增加了两个创建线程的方式，即实现java.util.concurrent.Callable接口和线程池。下面是这4种方式创建线程的代码实现。
1.继承Thread类
//继承Thread类来创建线程
public class ThreadTest {
public static void main(String[] args) {
//设置线程名字
Thread.currentThread().setName("main thread");
MyThread myThread = new MyThread();
myThread.setName("子线程:");
//开启线程
myThread.start();
for(int i = 0;i<5;i++){
System.out.println(Thread.currentThread().getName() + i);
}
}
}
class MyThread extends Thread{
//重写run()方法
public void run(){
for(int i = 0;i < 10; i++){
System.out.println(Thread.currentThread().getName() + i);
}
}
}
多线程和线程池
什么是进程
进程是指运行中的应用程序，每个进程都有自己独立的地址空间(内存空间)，比如用户点击桌面的IE浏览器，就启动了一个进程，操作系统就会为该进程分配独立的地址空间。当用户再次点击左面的IE浏览器，又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。目前操作系统都支持多进程。
要点：用户每启动一个进程，操作系统就会为该进程分配一个独立的内存空间。
什么是线程
所谓线程，就是进程中一个实体，是被系统独立调度和分派的基本单位，线程本身不具有系统资源的调度权，仅仅拥有一点点用于在系统中运行所需的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。
一个线程可以创建和撤销其他的线程，同一进程中的多个线程之间可以并发执行，线程有就绪、阻塞、运行三种基本状态。
image.png
关于阻塞状态有以下三个
等待阻塞：执行wait()方法等待，由notify()或notifyAll()唤醒
同步阻塞:使用同步锁synchronized上锁
其他阻塞:执行sleep()或join()方法，或者发出了I/O请求时
线程的wait阻塞
Wait()方法是让线程释放对象锁，让让其他线程拿到锁之后去优先执行，当其他线程唤醒wait()中的线程或者拿到对象锁的线程执行完释放了对象锁之后，wait（）中的线程才会再次拿到对象锁从而执行。
线程的sleep阻塞
Sleep()方法是让线程睡眠，此时并没有释放对象锁，其他想要拿到睡眠线程的对象锁的线程也就拿不到相应的对象锁，从而不能抢在他前面执行。
多线程的安全问题
多个线程之间为什么会出现不安全
线程随机性原理，线程会被CPU随机切换，而线程访问的资源如果是堆或者方法取得资源的话，那么每个线程都可以改变这个数据，外加上线程额执行会被CPU随机切换。
多线程中对同步锁的使用
· 解决线程安全问题
①使用synchronized同步锁的引用
②使用对象锁(对当前对象进行加锁)
③synchronized锁多对象
多线程案例
1.我锁住了一个方法，当我执行了这个方法，其他方法能够执行这个方法么？
能
2.我锁的是这个对象呢？
获得当前对象锁的线程，在调用加锁的方法，不会阻塞；
调用该对象普通方法(既没有同步的方法)，不会阻塞；
既没有获得锁，调用的又是同步方法或代码块，会被阻塞。
3.在类中有两个对象，我对class加锁，我对class中的一个对象进行访问，其他线程能够访问另一个对象么？
不能，锁住整个class时，锁只能在方法执行后备释放才能执行其他方法或本方法，因为当前处于被锁定的范围中。
这里要注意，锁住class和锁住this是不同的，锁住this时类中的其他对象或方法可以被另一条线程使用，而锁住class时是不行的。、
什么是线程池？怎么使用？
线程池
线程池是一种多线程处理方法，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程，每个线程使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程处于空闲状态，线程池将会调度一个任务给它。如果所有线程都始终保持繁忙，但将任务放入到一个队列总，则线程池将在过一段时间后创建另一个辅助线程，但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。
线程池的工作原理
大佬文章带你解密：https://www.cnblogs.com/easycloud/p/3726089.html
线程池的参数有哪些？
1.corePoolSize:核心线程数
2.queueCapacity:任务队列容量(阻塞队列)
3.maxPoolSize：最大线程数
4.keepAliveTime:线程空闲时间
5.allowCoreThreadTimeOut:允许核心线程超时
6.rejectedExecutionHandler:任务拒绝处理器
队列
线程池的队列长度是无限大的，但是在实际生产环境下，当请求速度远大于处理速度时，队列的无限假如会造成资源耗尽，服务宕掉。
线程被释放后会被杀掉？
不会，会回到池子中，等待线程池的再次调度。
知道线程数达到最大值后，会发生什么事么？
剩下的请求任务会进入等待队列
线程池在实际开发项目中的使用：
①在执行消息入库的时候需要线程池，使用通用线程池，用于异步执行写操作不影响主程序
②在上传图片的时候，后台服务器是不支持多张图片上传的，利用线程池可以进行多张图片上传，从而减少上传的时间。
https://blog.csdn.net/androidstarjack/article/details/81124183
常用的线程池有4种
1.newCachedThreadPool----创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
2.newFixedThreadPool----创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。
3.newSingleThreadExecutor----创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO，LIFO,优先级)执行
FIFO:先进先出
LIFO:后进先出
4.newSchedule ThreadPool----创建一个定长的线程池，而且支持定时的以及周期性的任务执行。
线程池案例链接地址-------https://www.cnblogs.com/aaron911/p/6213808.html
线程池中的数据库连接池，它有什么好处？
数据库连接池负责分配，管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。
原因：数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现的尤为突出，对数据库连接的管理显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。
创建多线程方式
1.线程是什么？
线程被称为轻量级进程，是程序执行的最小单位，它是指在程序执行过程中，能够执行代码的一个执行单位。每个程序都至少有一个线程，也就是程序本身
2.线程状态
Java语言自定义了5种线程状态，在任意一个时间点，一个线程只能有且只有其中一个状态
①新建(new):创建后尚未启动的线程处于这种状态
②运行(Runnable):Runnable包括了操作系统线程状态得我Running和Ready，也就是处于此线程状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间。
③等待(Waiting)：处于这种状态的线程不会被分配CPU执行时间。等待状态又分为无期限等待和有期限等待，处于无期限等待的线程需要被其他线程显示地唤醒，没有设置Timeout参数的Object.wait()、没有设置Timeout参数的Thread.join()方法都会使线程进入无限期等待状态；有限期等待状态无须等待被其他线程显示地唤醒，在一定时间之后它们会由系统自动唤醒，Thread.sleep()、设置了Timeout参数的Object.wait()、设置了Timeout参数的Thread.join()方法都会使线程进入有限期等待状态。
④阻塞(Blocked):线程被阻塞了，"阻塞状态"与“等待状态”的区别是：“阻塞状态”在等待着获取到一个排他锁，这个时间将在另外一个线程放弃这个锁的时候发生；而"等待状态"则是在等待一段时间或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将进入这种状态。
⑤结束(Terminated):已终止线程的线程状态，线程已经结束执行。
下图是5种状态转换图：
image.png
线程同步方法
线程有4种同步方法：wait()、sleep()、notify()、notifyAll()
wait()：使线程处于一种等待状态，释放所持有的的对象锁。
sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用它时要捕获InterruptedException异常，不释放对象锁。
notify()：唤醒一个正在等待状态的线程。注意调用此方法时，并不能确切知道唤醒的是哪一个等待状态的线程，是由JVM来决定唤醒哪个线程，不是由线程优先级决定的。
notifyAll()：唤醒所有等待状态的线程，注意并不是给所有唤醒线程一个对象锁，而是让它们竞争。
创建线程的方式
在JDK1.5之前，创建线程就只有两种方式，即继承java.lang.Thread类和实现java.lang.Runnable接口；而在JDK1.5以后，增加了两个创建线程的方式，即实现java.util.concurrent.Callable接口和线程池。下面是这4种方式创建线程的代码实现。
1.继承Thread类
//继承Thread类来创建线程
public class ThreadTest {
public static void main(String[] args) {
//设置线程名字
Thread.currentThread().setName("main thread");
MyThread myThread = new MyThread();
myThread.setName("子线程:");
//开启线程
myThread.start();
for(int i = 0;i<5;i++){
System.out.println(Thread.currentThread().getName() + i);
}
}
}
class MyThread extends Thread{
//重写run()方法
public void run(){
for(int i = 0;i < 10; i++){
System.out.println(Thread.currentThread().getName() + i);
}
}
}
2.实现Runnable接口
//实现Runnable接口
public class RunnableTest {
public static void main(String[] args) {
//设置线程名字
Thread.currentThread().setName("main thread:");
Thread thread =new Thread(new MyRunnable());
thread.setName("子线程:");
//开启线程
thread.start();
for(int i = 0; i <5;i++){
System.out.println(Thread.currentThread().getName() + i);
}
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + i);
}
}
}
3.实现Callable接口
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//实现Callable接口
public class CallableTest {
public static void main(String[] args) {
//执行Callable 方式，需要FutureTask 实现实现，用于接收运算结果
FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
new Thread(futureTask).start();
//接收线程运算后的结果
try {
Integer sum = futureTask.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
sum += i;
}
return sum;
}
}
4.线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//线程池实现
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
//创建线程池
ExecutorService executorService = Executors.newFixedThreadPool(10);
ThreadPool threadPool = new ThreadPool();
for(int i =0;i<5;i++){
//为线程池分配任务
executorService.submit(threadPool);
}
//关闭线程池
executorService.shutdown();
}
}
class ThreadPool implements Runnable {
@Override
public void run() {
for(int i = 0 ;i<10;i++){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
