一、多线程
1,概述
进程是指正在运行的程序。
线程是被包含在进程里。是操作系统能够调度的最小单位,也是实际的运作单位。
一个软件的运行需要依赖至少一个进程。
一个进程的运行需要依赖至少一个线程。
单线程是有1个线程,效率低。多线程拥有>1的线程数,来提高效率。
2、多线程的特性
2.1、随机性
2.2线程状态
线程生命周期,总共有五种状态:
1) 新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t = new MyThread()。
2) 就绪状态(Runnable):当调用线程对象的start()方法(t.start();),线程即进入就绪状态。处于就绪状态的线程,只是说明此线程已经做好了准备,随时等待CPU调度执行,并不是说执行了t.start()此线程立即就会执行。
3) 运行状态(Running):当CPU开始调度处于就绪状态的线程时,此时线程才得以真正执行,即进入到运行状态。注:就绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中。
4) 阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才有机会再次被CPU调用以进入到运行状态
5) 根据阻塞产生的原因不同,阻塞状态又可以分为三种:
a) 等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态。
b) 同步阻塞:线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态。
c) 其他阻塞:通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
6) 死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
1.1进程
1.1.1概述
就是正在运行的程序。也就是代表了程序锁占用的内存区域。
1.1.2特点
独立性:进程是系统中独立存在的实体,它可以拥有自己的独立的资源,每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间。
动态性:进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念,进程具有自己的生命周期和各种不同的状态,这些概念在程序中都是不具备的。
并发性:多个进程可以在单个处理器上并发执行,多个进程之间不会互相影响。
1.2线程
1.2.1概述
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一个进程可以开启多个线程。
多线程扩展了多进程的概念,使得同一个进程可以同时并发处理多个任务。
简而言之,一个程序运行后至少一个进程,一个进程里包含多个线程。
如果一个进程只有一个线程,这种程序被称为单线程。
如果一个进程中有多条执行路径被称为多线程程序。
1.2.2进程和线程的关系
从图中可以看出一个操作系统中可以有多个进程,一个进程中可以有多个线程,每个进程有自己独立的内存,每个线程共享一个进程中的内存,每个线程又有自己独立的内存。(记清这个关系,非常重要!)
所以想使用线程技术,得先有进程,进程的创建是OS创建的,你能实现吗?不能,一般都是c或者c++语言完成的。
二、多线程创建:继承Thread
2.1概述
Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。Start()方法是一个native方法,它将通知底层操作系统,最终由操作系统启动一个新线程,操作系统将执行run()方法。这种方式实现多线程很简单,通过自己的类直接extend Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。
模拟开启多个线程,每个线程调用run()方法。
2.2常用方法
package cn.tedu.util;
//测试Thread工具类
public class Test3 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread();
System.out.println(t.getId());//获取线程的id
t.setName("王林");//设置线程名称
System.out.println(t.getName());//获取线程的名字
t.run();//运行
t.start();//开启线程
t.stop();//结束线程
Thread.sleep(100);//使线程休眠//静态方法12和13行
Thread t1 = Thread.currentThread();//获取正在执行的线程对象
System.out.println(t1.getName());//获取正在执行任务的线程的名字
System.out.println(Thread.currentThread().getName());
}
}
2.3模拟多线程
package cn.tedu.util;
//测试 模拟多线程编程
public class Test4 {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
new MyThread().start();//启动线程
// new MyThread().run();//没有多线程的效果
//start()--1,启动线程--2,找到线程类的run()运行
//new MyThread() --线程是新建状态
//start() -- 从新建状态变成可运行状态(等着CPU选中)
}
// Thread-1=9//MyThread m = new MyThread();
// Thread-0=0//m.run();//m.start();
// 这种方法不会出现上面注释的0和1,会全部都是0
}
}
class MyThread extends Thread{
@Override
public void run(){//使线程从可运行状态变换成运行状态
for (int i = 0; i < 4; i++) {
System.out.println(super.getName()+"="+i);
}
}//使线程从运行状态变换成 终止状态
}
三、多线程创建:实现Runnable接口
3.1概述
如果自己的类已经extends另一个类,就无法多继承,此时,可以实现一个Runnable接口。
3.2常用方法
package cn.tedu.util;
public class Test5 {
public static void main(String[] args) {
MyRunnable target = new MyRunnable();
// Thread t = new Thread(target);//绑定目标类和Thread类的关系
// t.start();
// Thread t1 = new Thread(target);//绑定目标类和Thread类的关系
// t1.start();
// new Thread(target).start();
for (int i = 0; i < 4; i++) {
Thread t = new Thread(target);//绑定目标类和Thread类的关系
t.start();
}
}
}
class MyRunnable implements Runnable{
@Override
public void run(){
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"="+i);
//利用Thread提供的静态方法currentThread(),
// 获取正在执行任务getName()的线程名称
}
}
}
四、比较
五、同步锁synchronized
5.1概述
把有可能出现问题的代码包起来,一次只让一个线程执行。通过sychronized关键字实现同步。
当多个对象操作共享数据时,可以使用同步锁解决线程安全问题。
5.2语法
用在方法上:synchronized public void show(){...}
用在代码块上:锁哪+锁谁:synchronized(对象){
需要同步的代码;
}
5.3特点
1、 前提1,同步需要两个或者两个以上的线程。
2、 前提2,多个线程间必须使用同一个锁。
3、 同步的缺点是会降低程序的执行效率, 为了保证线程安全,必须牺牲性能。
4、 可以修饰方法称为同步方法,使用的锁对象是this。
5、 可以修饰代码块称为同步代码块,锁对象可以任意。
实现Runable接口
package cn.yedu.util;
//测试 多线程售票
//需求:设计4个售票窗口,总计售票100张
public class Test2 {
public static void main(String[] args) {
MyTickets target = new MyTickets();
for (int i = 0; i < 4; i++) {//利用4个线程执行同一个任务
new Thread(target).start();
}
}
}
//创建多线程类售票 -- implements Runnable
class MyTickets implements Runnable{
int tickets = 100;
Object obj = new Object();
@Override
//1,给方法加锁,实现了同步方法,保证了访问方法时必须排队等待不抢了,保证了数据安全
// synchronized public void run() {
public void run() {
while (true){
//2,给代码块加锁,实现同步代码块,实现了访问代码块要排队等待的效果
//锁哪儿--从共享资源被第一次使用开始,到用完结束
//锁对象是谁--可以任意,必须是同一个对象
// synchronized ("hello"){//可以
// synchronized (this){//可以
// synchronized (new Object()){//不可以
synchronized (obj){//可以
if (tickets > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "~~" + tickets--);
} else {
break;
}
}
}
}
}
继承Thread类
package cn.yedu.util;
//测试 多线程售票
//需求:设计4个售票窗口,总计售票100张
public class Test1 {
public static void main(String[] args) {
for (int i = 0; i < 4; i++) {//用4个线程模拟4个窗口
new Ticket().start();//启动线程
}
}
}
//创建多线程类售票 -- extends Thread
class Ticket extends Thread{
static int tickets = 100;
//2,方法可以被同步修饰,普通方法,会自动分配this对象
//静态方法,会自动分配类名.class对象
public void run() {
while(true){
//1,锁对象是谁?--如果共享资源是普通资源,锁对象可以任意
//--如果共享资源是静态资源,锁对象必须是类名.class
synchronized (Ticket.class){
if (tickets > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(super.getName() + "==" + tickets--);
} else {
break;//结束死循环
}
}
}
}
}
六、线程锁
6.1悲观锁和乐观锁
1、 悲观锁:还是像它的名字一样,对于并发间操作产生的线程安全问题持悲观状态,悲观锁认为竞争总是会发生,因此每次对某资源进行操作时,都会持有一个独占的锁,就像synchronized,不管三七二十一,直接上了锁就操作资源了。
2、 乐观锁:就像它的名字一样,对于并发间操作产生的线程安全问题持乐观状态,乐观锁认为竞争不总是会发生,因此它不需要持有锁,将比较-替换这两个动作作为一个原子操作尝试去修改内存中的变量,如果失败则表示发生冲突,那么就应该有相应的重试逻辑。
6.2两种常见的锁
1、 Synchronized 互斥锁(悲观锁,有罪假设)
1.1 采用synchronized修饰符实现的同步机制叫做互斥锁机制,它所获得的锁叫做互斥锁。每个对象都有一个monitor(锁标记),当线程拥有这个锁标记时才能访问这个资源,没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁,这个锁是为了分配给线程的,防止打断原子操作。每个对象的锁只能分配给一个线程,因此叫做互斥锁。
2、 ReentrantReadWriteLock 读写锁(乐观锁,无罪假设)
2.1 ReentrantLock是排他锁,排他锁在同一时刻仅有一个线程可以进行访问,实际上独占锁是一种相对比较保守的锁策略,在这种情况下任何“读/读”、“读/写”、“写/写”操作都不能同时发生,这在一定程度上降低了吞吐量。然而读操作之间不存在数据竞争问题,如果”读/读”操作能够以共享锁的方式进行,那会进一步提升性能。因此引入了ReentrantReadWriteLock,顾名思义,ReentrantReadWriteLock是Reentrant(可重入)Read(读)Write(写)Lock(锁),我们下面称它为读写锁。
2.2 读写锁内部又分为读锁和写锁,读锁可以在没有写锁的时候被多个线程同时持有,写锁是独占的。读锁和写锁分离从而提升程序性能,读写锁主要应用于读多写少的场景。
6.3两种方式的区别
需要注意的是,用sychronized修饰的方法或者语句块在代码执行完之后锁会自动释放,而是用Lock需要我们手动释放锁,所以为了保证锁最终被释放(发生异常情况),要把互斥区放在try内,释放锁放在finally内!
与互斥锁相比,读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程(writer 线程)可以修改共享数据,但在许多情况下,任何数量的线程可以同时读取共享数据(reader 线程)从理论上讲,与互斥锁定相比,使用读-写锁允许的并发性增强将带来更大的性能提高。
6.4自旋
很多synchronized里面的代码只是一些很简单的代码,执行时间非常快,此时等待的线程都加锁可能是一种不太值得的操作,因为线程阻塞涉及到用户态和内核态切换的问题。既然synchronized里面的代码执行得非常快,不妨让等待锁的线程不要被阻塞,而是在synchronized的边界做忙循环,这就是自旋。如果做了多次忙循环发现还没有获得锁,再阻塞,这样可能是一种更好的策略。
While(true) {
synchronized (this) {
if(ticket<=0) {
break;
}
System.out.println(“窗口:” + Thread.currentThread().getName()
+”, 剩余票数:” + ticket-- );
}
6.5线程创建的其他方式(线程池)
用来存放就绪状态的线程,提高线程的高可用。
两个过程:取出来+还回池里。
6.5.1ExecutorService/Executors
package cn.yedu.util;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//线程池测试
//测试 多线程售票
//需求:设计4个售票窗口,总计售票100张
public class Test3 {
public static void main(String[] args) {
MyTicketss target = new MyTicketss();
ExecutorService pool = Executors.newFixedThreadPool(4);
//线程池:线程复用高 + 托管
//1,创建 拥有固定大小的 线程池
for (int i = 0; i < 4; i++) {//利用4个线程执行同一个任务
// new Thread(target).start();//被线程池代替
// //2,利用池里的线程执行目标任务
pool.execute(target);
}
}
}
//创建多线程类售票 -- implements Runnable
class MyTicketss implements Runnable{
int tickets = 100;
Object obj = new Object();
@Override
//1,给方法加锁,实现了同步方法,保证了访问方法时必须排队等待不抢了,保证了数据安全
// synchronized public void run() {
public void run() {
while (true){
//2,给代码块加锁,实现同步代码块,实现了访问代码块要排队等待的效果
//锁哪儿--从共享资源被第一次使用开始,到用完结束
//锁对象是谁--可以任意,必须是同一个对象
// synchronized ("hello"){//可以
// synchronized (this){//可以
// synchronized (new Object()){//不可以
synchronized (obj){//可以
if (tickets > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "~~" + tickets--);
} else {
break;
}
}
}
}
}
6.5.2Callable/Future
package game;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Test6 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService pool = Executors.newSingleThreadExecutor();
C1 c1 = new C1();
//任务c1放入线程池并行执行
Future<Double> future = pool.submit(c1);
Double r = future.get();//获取结果
System.out.println(r);
pool.shutdown();//关闭任务
}
}
class C1 implements Callable<Double> {
@Override
public Double call() throws Exception {
return Math.random();
}
}
七、设计模式
7.1概述
单例模式可以说是大多数开发人员在实际中使用最多的,常见的Spring默认创建的bean就是单例模式的。
单例模式有很多好处,比如可节约系统内存空间,控制资源的使用。
其中单例模式最重要的是确保对象只有一个。
简单来说,保证一个类在内存中的对象就一个。
RunTime就是典型的单例设计。
饿汉式:
package cn.tedu.design;
//测试 单例模式--一个类仅有一个实例
public class Test1 {
public static void main(String[] args) {
Person p1 = Person.get();
System.out.println(p1);
Person p2 = Person.get();
System.out.println(p2);
// new Person();
// Person p = Person.get();和p1、p2一样
// Person pp = Person.get();
//比了地址值,相同对象得到true
System.out.println(p1 == p2);
//== 和 equals()的区别???
//==比较引用类型间的地址值,比较基本类型的值本身
//equals()默认就是==比,可以重写成比属性值
}
}
//饿汉式
class Person{
//1,不让外界new--私有化构造方法
private Person(){}
//2,自己new一个给外界准备着
//加static ,想要被静态的方法get()调用成功,p必须也得是静态的
static private Person p = new Person();
//3,提供一个方法,返回p
//加static ,get()不能通过对象调用,可以直接利用类名调用
static public Person get(){
return p;//把自己创建好的对象返回
}
}
懒汉式:
package cn.tedu.design;
//测试 单例模式--一个类仅有一个实例
public class Test2 {
public static void main(String[] args) {
Student a = Student.get();
Student b = Student.get();
System.out.println(a);
System.out.println(b);
System.out.println( a == b);
}
}
//懒汉式 -- 按需加载 -- 线程安全的解决方案
class Student{
//1,私有化构造方法
private Student(){}
//2,给外界new一个
//共享资源被多条语句操作了,一定有安全隐患--需要加锁
static private Student s ;
//3,给外界返回s --按需加载
//静态的同步方法,自动分配的锁对象是类名.class
synchronized static public Student get(){
// 静态资源的锁对象必须是类名.class
// synchronized (Student.class) {
if (s == null) {//没new过才new
s = new Student();
}
return s;
// }
}
}
八、拓展
8.1.run()和start()的区别
run()只是一个普通的方法调用,没有多线程随机的效果,不能启动线程。 start()开启线程,找到线程里的业务执行。
8.2.JVM启动是单线程还是多线程
多线程,最少要启动main线程和GC线程。
8.3.守护线程
setDaemon(true)
后台线程、守护线程。
JVM虚拟机退出条件,是所有前台线程结束,当所有前台线程结束,虚拟机会自动退出。
不会等待后台线程结束。
例如:垃圾回收器是一个后台线程 。