【转】 【JavaSE】多线程与并发编程(总结)
一、多线程概述
参考:https://www.cnblogs.com/zsql/p/11144688.html
进程与线程
进程与线程的区别
-
线程是程序执行的最小单位,而进程是操作系统分配资源的最小单位
-
一个进程由一个或多个线程组成,线程是一个进程中代码的不同执行路线
-
进程之间相互独立,但同一进程下的各个线程之间共享程序的内存空间 (包括代码段,数据集,堆等) 及一些进程级的资源(如打开文件和信号等),某进程内的线程在其他进程不可见
-
调度和切换:线程上下文切换比进程上下文切换要快得多
线程(栈+PC+TLS)
-
栈:用于存储该线程的局部变量,这些局部变量是该线程私有的,除此之外还用来存放线程的调用栈祯。
我们通常都是说调用堆栈,其实这里的堆是没有含义的,调用堆栈就是调用栈的意思。
那么我们的栈里面有什么呢?
我们从主线程的入口main函数,会不断的进行函数调用,
每次调用的时候,会把所有的参数和返回地址压入到栈中。 -
PC:是一块内存区域,用来记录线程当前要执行的指令地址 。
Program Counter 程序计数器,操作系统真正运行的是一个个的线程,
而我们的进程只是它的一个容器。PC就是指向当前的指令,而这个指令是放在内存中。
每个线程都有一串自己的指针,去指向自己当前所在内存的指针。
计算机绝大部分是存储程序性的,说的就是我们的数据和程序是存储在同一片内存里的
这个内存中既有我们的数据变量又有我们的程序。所以我们的PC指针就是指向我们的内存的。 -
缓冲区溢出
例如我们经常听到一个漏洞:缓冲区溢出
这是什么意思呢?
例如:我们有个地方要输入用户名,本来是用来存数据的地方。
然后黑客把数据输入的特别长。这个长度超出了我们给数据存储的内存区,这时候跑到了
我们给程序分配的一部分内存中。黑客就可以通过这种办法将他所要运行的代码
写入到用户名框中,来植入进来。我们的解决方法就是,用用户名的长度来限制不要超过
用户名的缓冲区的大小来解决。 -
TLS:
全称:thread local storage
之前我们看到每个进程都有自己独立的内存,这时候我们想,我们的线程有没有一块独立的内存呢?答案是有的,就是TLS。
可以用来存储我们线程所独有的数据。
可以看到:线程才是我们操作系统所真正去运行的,而进程呢,则是像容器一样他把需要的一些东西放在了一起,而把不需要的东西做了一层隔离,进行隔离开来。
并行与并发
并发:是指同一个时间段
内多个任务同时都在执行,并且都没有执行结束。并发任务强调在一个时间段内同时执行,而一个时间段由多个单位时间累积而成,所以说并发的多个任务在单位时间内不一定同时在执行 。
并行:同一时刻
上多个任务同时在执行 。
在多线程编程实践中,线程的个数往往多于CPU的个数,所以一般都称多线程并发编程而不是多线程并行编程。
线程安全问题
多个线程同时操作共享变量1
时,会出现线程1更新共享变量1的值,但是其他线程获取到的是共享变量没有被更新之前的值。就会导致数据不准确问题。
共享内存不可见性问题
- Java 内存模型规定,将所有的变量都存放在主内存中,当线程使用变量时,会把主内存里面的变量复制到自己的工作空间或者叫作工作内存,线程读写变量时操作的是自己工作内存中的变量 。(如下图所示)
上图中所示是一个双核 CPU 系统架构,每个核有自己的控制器和运算器,其中控制器包含一组寄存器和操作控制器,运算器执行算术逻辅运算。CPU的每个核都有自己的一级缓存,在有些架构里面还有一个所有CPU都共享的二级缓存。 那么Java内存模型里面的工作内存,就对应这里的 Ll或者 L2 缓存或者 CPU 的寄存器
-
线程A首先获取共享变量X的值,由于两级Cache都没有命中,所以加载主内存中X的值,假如为0。然后把X=0的值缓存到两级缓存,线程A修改X的值为1,然后将其写入两级Cache,并且刷新到主内存。线程A操作完毕后,线程A所在的CPU的两级Cache内和主内存里面的X的值都是1。
-
线程B获取X的值,首先一级缓存没有命中,然后看二级缓存,二级缓存命中了,所以返回X=1;到这里一切都是正常的,因为这时候主内存中也是X=l。然后线程B修改X的值为2,并将其存放到线程2所在的一级Cache和共享二级Cache中,最后更新主内存中X的值为2,到这里一切都是好的。
-
线程A这次又需要修改X的值,获取时一级缓存命中,并且X=l这里问题就出现了,明明线程B已经把X的值修改为2,为何线程A获取的还是l呢?这就是共享变量的内存不可见问题,也就是线程B写入的值对线程A不可见。
synchronized 的内存语义:
这个内存语义就可以解决共享变量内存可见性问题。进入synchronized块的内存语义是把在synchronized块内使用到的变量从线程的工作内存中清除,这样在synchronized块内使用到该变量时就不会从线程的工作内存中获取,而是直接从主内存中获取。退出synchronized块的内存语义是把在synchronized块内对共享变量的修改刷新到主内存。会造成上下文切换的开销,独占锁,降低并发性
Volatile的理解:
该关键字可以确保对一个变量的更新对其他线程马上可见。当一个变量被声明为volatile时,线程在写入变量时不会把值缓存在寄存器或者其他地方,而是会把值刷新回主内存。当其他线程读取该共享变量时-,会从主内存重新获取最新值,而不是使用当前线程的工作内存中的值。volatile的内存语义和synchronized有相似之处,具体来说就是,当线程写入了volatile变量值时就等价于线程退出synchronized同步块(把写入工作内存的变量值同步到主内存),读取volatile变量值时就相当于进入同步块(先清空本地内存变量值,再从主内存获取最新值)。不能保证原子性
二、实现多线程
方式1:继承Thread类
需求:我们要实现多线程的程序。 如何实现呢?
由于线程是依赖进程而存在的,所以我们应该先创建一个进程出来。
而进程是由系统创建的,所以我们应该去调用系统功能创建一个进程。
Java是不能直接调用系统功能的,所以,我们没有办法直接实现多线程程序。 但是呢? Java可以去调用C / C++写好的程序来实现多线程程序。
由C/C++去调用系统功能创建进程,然后由Java去调用这祥的API, 然后提供一些类供我们使用。我们就可以实现多线程程序了。
那么Java提供的类是什么呢?
- Thread类
步骤 - A : 自定义类
MyThread
继承Thread
- B : 重写run () 方法
- 为什么是run ()方法呢?
- C :创建对象
- D : 启动线程
注意:单独调用 run() 方法其实和调用一个类的普通方法是没有区别的,要想启动线程实际上应该调用的是 start() 方法,这是为什么呢?
start() 和 run() 的区别?
- start() :
使该线程开始执行;Java 虚拟机调用该线程的 run() 方法。
用start方法来启动线程,真正实现了多线程运行,这时无需等待run方法体中的代码执行完毕而直接继续执行后续的代码。通过调用Thread类的 start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,一旦得到cpu时间片,就开始执行run()方法,这里的run()方法 称为线程体,它包含了要执行的这个线程的内容,Run方法运行结束,此线程随即终止。
- run() :
如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回
。
Thread 的子类应该重写该方法。
run()方法只是类的一个普通方法而已,如果直接调用Run方法,程序中依然只有主线程这一个线程,其程序执行路径还是只有一条,还是要顺序执行
,还是要等待run方法体执行完毕后才可继续执行下面的代码,这样就没有达到写线程的目的。
总结:
两个小问题
- 为什么要重写 run()方法?
- 因为run()是用来封装被线程执行的代码
- run() 方法和 start() 方法的区别?
- run():封装线程执行的代码,直接调用,相当于普通方法的调用
- start():启动线程;然后由
JVM调用
此线程的run()方法
创建自定义线程代码:
//定义一个线程类
public class MyThread extends Thread {
@Override
public void run() {
for(int i=0; i<100; i++) {
System.out.println(i);
}
}
}
//调用方法执行线程
public class MyThreadDemo {
public static void main(String[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
// my1.run();
// my2.run();
//void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
my1.start();
匿名内部类的方式创建一个线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程");
}
}).start();
获取和设置线程对象名称
//void setName(String name):将此线程的名称更改为等于参数 name
my1.setName("高铁");
my2.setName("飞机");
//Thread(String name)
MyThread my1 = new MyThread("高铁");
MyThread my2 = new MyThread("飞机");
System.out.println(Thread.currentThread().getName());
线程优先级
线程控制
等待线程死亡
public class ThreadTest {
public static void main(String[] args) {
ThreadDemo th1=new ThreadDemo();
ThreadDemo th2=new ThreadDemo();
ThreadDemo th3=new ThreadDemo();
th1.setName("康熙");
th2.setName("四阿哥");
th3.setName("八阿哥");
th1.start();
try {
th1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
//下面的两个线程会等待康熙线程死亡以后才开始执行
th2.start();
th2.start();
}
}
守护线程
th1.setName("刘备");
th2.setName("张飞");
th3.setName("关羽");
th2.setDaemon(true);
th3.setDaemon(true);
th2.start();
th3.start();
th1.start();
//th2、th3 在th1死亡时,也会跟着死亡
礼让线程
/*
* public static void yield():暂停当前正在执行的线程对象,并执行其他线程。
* 让多个线程的执行更和谐,但是不能靠它保证一人一次。
*/
public class ThreadYield extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++){
System.out.println(getName() + ":" + i);
Thread.yield();//暂停当前正在执行的线程对象
}
}
}
public class TreadDemo {
public static void main(String[] args) {
ThreadYield th1 = new ThreadYield();
ThreadYield th2 = new ThreadYield();
th1.setName("呵呵");
th2.setName("哈哈");
th1.start();
th2.start();
}
}
JOJO:0
林青霞:0
JOJO:1
林青霞:1
JOJO:2
林青霞:2
JOJO:3
林青霞:3
JOJO:4
林青霞:4
JOJO:5
林青霞:5
JOJO:6
林青霞:6
JOJO:7
林青霞:7
林青霞:8
JOJO:8
林青霞:9
JOJO:9
林青霞:10
JOJO:10
林青霞:11
JOJO:11
林青霞:12
JOJO:12
林青霞:13
林青霞:14
JOJO:13
林青霞:15
JOJO:14
JOJO:15
林青霞:16
JOJO:16
林青霞:17
JOJO:17
JOJO:18
林青霞:18
JOJO:19
林青霞:19
Process finished with exit code 0
中断线程
stop() 中断线程很暴力,后面的程序都不走了
public boolean isInterrupted()
public void interrupt()
public static boolean interrupted()
线程的生命周期
方式2:实现Runnable接口
多线程的实现方案有两种
- 继承 Thread类
- 实现 Runnable接口
相比继承 Thread类,实现Runnable接口的好处 - 避免了 Java单继承的局限性
- 适合多个相同程序的代码去处理同一个资源的情况,把线程和程序的代码、数据有效分离,较好的体现了面向对象的设计思想
MyRunnable runnable = new MyRunnable();
Thread th1 = new Thread(runnable,"线程一");
Thread th2 = new Thread(runnable,"线程二");
th1.start();
th2.start();
/**
* 自定义runnable接口,
*/
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("自定义runnable接口下的run()方法执行了...");
}
}
方式3:实现Callable接口,线程池
三、线程安全问题
安全问题出现的条件
- 是多线程环境
- 有共享数据
- 有多条语句操作共享数据
同步的好处和弊端
- 好处:解决了多线程的数据安全问题
- 弊端:当线程很多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率
怎么实现呢 ?
- 把多条语句操作共享数据的代码给锁起来,让任意时刻只能有一个线程执行即可
- Java 提供了同步代码块的方式来解决
synchronized
方式一:synchronized 同步代码块
Object obj=new Object();
synchronized (obj) {
多条语句操作共享数据的代码
}
Lock类
方式二:Lock类
- Lock是接口不能直接实例化,这里采用它的实现类
ReentrantLock
来实例化 - 使用
try....finally
代码块来包裹
private int ticket=100;
private Lock lock=new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock();
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票" + ticket);
ticket--;
}
}finally {
lock.unlock();
}
线程安全的集合
回顾:StringBuffer、Vector、Hashtable集合
四、练习案例
两种匿名内部类方式创建线程
public class TreadDemo02 {
public static void main(String[] args) {
// 继承Thread类实现多线程
new Thread(){
@Override
public void run() {
for (int i = 0; i<20;i++){
System.out.println(Thread.currentThread().getName() + ": Thread : " + i);
}
}
}.start();
// 实现Runnable接口实现多线程
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i<20;i++){
System.out.println(Thread.currentThread().getName() + ": Runnable : " + i);
}
}
}){
//thread子类
}.start();
}
}
简单面试题 01
1:多线程有几种实现方案,分别是哪几种?
两种。
继承Thread类
实现Runnable接口
扩展一种:实现Callable接口。这个得和线程池结合。
2:同步有几种方式,分别是什么?
两种。
同步代码块
同步方法
3:启动一个线程是run()还是start()?它们的区别?
start();
run():封装了被线程执行的代码,直接调用仅仅是普通方法的调用
start():启动线程,并由JVM自动调用run()方法
4:sleep()和wait()方法的区别
sleep():必须指时间;不释放锁。
wait():可以不指定时间,也可以指定时间;释放锁。
5:为什么wait(),notify(),notifyAll()等方法都定义在Object类中
因为这些方法的调用是依赖于锁对象的,而同步代码块的锁对象是任意锁。
而Object代码任意的对象,所以,定义在这里面。
回顾集合和IO的面试题
集合:
1: HashMap和Hashtable的区别。
2:Collection 和 Collections的区别。
3: List, Set, Map是否继承自Collection接口?
4:说出ArrayList,Vector, LinkedList的存储性能和特性?
5:你所知道的集合类都有哪些?主要方法?
IO:
1: java中有几种类型的流?JDK为每种类型的流提供了一些抽象类以供继承,请说出他们分别是哪些类?
2:什么是java序列化,如何实现java序列化?