多进程,多线程
线程
线程使用的是系统资源,该系统资源是操作系统分配给当前进程使用的,多个线程的情况下,同时[抢占执行]会导致资源紧缺
一个Java程序,最少有2个线程:
- main线程
- JVM的GC机制,守护线程
并行和并发
-
并发
两个或者两个以上的十五在同一个时间段发生
-
并行
两个或者两个以上的事务在同一个时刻发生
宏观并行,微观串行
-
高并发
在一个时间段内,发生众多事情
多线程
优缺点
优点:
- 提升资源利用率
- 提高用户体验
缺点:
- 降低了其他线程的执行概率
- 用户会感受到软件的卡顿问题
- 增加了系统资源压力
- 多线程情况下的共享资源问题,线程冲突,线程安全问题
创建线程
-
class Thread
Java中的一个线程类
Thread类是Runnable接口的实现类,同时提供了很多线程的操作使用的方法
-
interface Runnable接口
规定了what will be run?
里面只有一个run方法
创建自定义线程类的方式
-
自定义线程类,继承Thread类,重写run方法
创建自定义线程对象,直接调用start方法,开启线程
-
自定义线程类,遵从Runnable接口
使用自定义遵从接口Runnable实现类对象,作为Thread构造方法参数
借助于Thread类对象和start方法,开启线程
package cn.ocean888;
/*
* 方法1
* 继承Thread类自定义线程类
*/
class MyThread1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("继承Thread类自定义线程类");
}
}
}
/*
* 方法2
* 自定义线程类MyThread2遵从Runable接口
*/
class MyThread2 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("自定义线程类MyThread2遵从Runable接口");
}
}
}
public class Demo {
public static void main(String[] args) {
// 1.创建一个继承Thread类自定义线程类对象
MyThread1 myThread1 = new MyThread1();
// 这里不是启动线程,而是将run方法作为一个普通方法执行
// myThread1.run()
// 正确方法
myThread1.start();
// 2.创建一个Thread类对象,使用遵从Runnable接口的实现类作为构造方法参数
Thread thread = new Thread(new MyThread2());
// 借助于Thread类内的start方法开启线程
thread.start();
// 3.匿名内部类方法
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类方式创建对象,作为线程执行代码");
}
}).start();
}
}
Thread类需要了解的方法
构造方法Constructor
-
Thread();
分配一个新的线程对象,无目标,无指定名字,存在默认名字
-
Thread(Runnable target);
创建一个新的线程对象,并且在创建线程对象的过程中,使用Runnable接口的实现类对象作为执行的线程代码块目标
-
Thread(String name);
创建一个新的线程,无指定目标,但是指定当前线程的名字
-
Thread(Runnable target, String name);
创建一个线程的线程对象,使用Runnable接口实现类对象,作为执行目标,并且指定name作为线程名
成员方法
-
void setName(String name);
-
String getName();
以上两个是name属性setter和getter属性
-
void setPriority(int Priority);
设置线程的优先级,非一定执行要求,只是增加执行的概率
优先级数值范围[1-10] 10 最高,1最低,5默认
-
int getPriority();
获取线程优先级
-
void start();
启动线程对象
-
public static void sleep(int ms);
当前方法是静态方法,通过Thread类调用,要求是当前所在线程代码块对应的线程进行休眠操作,指定休眠指定的毫秒数
-
public static Thread currentThread();
当前方法是静态方法,通过Thread类调用,获取当前所处代码快对应的线程对象
构造方法实例:
package cn.ocean888;
public class Demo1 {
public static void main(String[] args) {
Thread thread1 = new Thread();
// 约束线程的名字
Thread thread2 = new Thread("ocean线程");
// 给予Thread类构造方法Runnable接口实现类对象
Thread thread3 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类作为线程的执行目标");
}
});
// 给予Thread类构造方法Runnable接口实现类对象,并且约定名字
Thread thread4 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类作为线程的执行目标");
}
}, "匿名内部类对象");
System.out.println(thread1);
System.out.println(thread2);
System.out.println(thread3);
System.out.println(thread4);
}
}
分别代表
Thread[ThreadName, ThreadPriority, ThreadGroup]
成员方法实例:
package cn.ocean888;
public class Demo2 {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程目标代码");
}
}, "ocean线程");
Thread currThread = Thread.currentThread();
System.out.println(thread.getName());
thread.setName("ocean线程2");
System.out.println(thread.getName());
System.out.println(thread.getPriority());
/*
* 优先级范围1-10
* Thread.MAX_PRIORITY 最大优先级10
* Thread.MIN_PRIORITY 最小优先级1
* Thread.NORM_PRIORITY 默认优先级5
*/
thread.setPriority(Thread.NORM_PRIORITY);
System.out.println(thread.getPriority());
}
}
线程安全问题和解决方案
线程安全问题-共享资源能使用问题
-
局部变量
在方法内,如果run方法执行,存在,run方法当前执行完毕,销毁
每一个线程对象中都有run方法,无法满足共享问题
-
成员变量
每一个线程对象中,都有一个对应的成员变量,非共享资源
-
静态成员变量
属于类变量,所有的当前类对象,使用的静态成员变量都是一个,而且一处修改,处处受影响[共享资源]
线程抢占实例:
package cn.ocean888;
class SingleThread implements Runnable{
private static int ticket = 100;
@Override
public void run() {
while (true) {
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "抢走了第" + ticket + "张票");
ticket -= 1;
} else {
System.out.println(Thread.currentThread().getName() + "售罄");
break;
}
}
}
}
public class Demo3 {
public static void main(String[] args) {
Thread thread1 = new Thread(new SingleThread(), "淘票票");
Thread thread2 = new Thread(new SingleThread(), "飞猪");
Thread thread3 = new Thread(new SingleThread(), "美团");
thread1.start();
thread2.start();
thread3.start();
}
}
会出现三个线程同时抢一张票
甚至会出现抢超过100张票
同步代码块
synchronized(/* 锁对象 */) {
}
特征:
- synchronized小括号里面的对象是锁对象,并且要求如果是多线程的情况下,锁对象必须是同一个对象
- synchronized大括号中的代码块就是需要进行同步的代码,或者说是加锁的代码,打括号里面的内容,有且只允许一个线程进入
- 同步代码块越短越好,在保证安全的情况下,提高性能
实例:
class SingleThread implements Runnable{
private static int ticket = 100;
@Override
public void run() {
while (true) {
synchronized ("lock") {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "抢走了第" + ticket + "张票");
ticket -= 1;
} else {
System.out.println(Thread.currentThread().getName() + "售罄");
break;
}
}
}
}
}
缺点:
- 锁对象很随意,有隐患
- 代码层级关系复杂
同步方法
synchronized作为关键字来修饰方法,修饰的方法就是对应的同步方法
有且只允许一个线程进入
-
静态成员方法
锁对象是当前类对应的字节码文件 类名.class
-
非静态成员方法
锁对象是当前类对象 this
静态成员方法实例:
package cn.ocean888;
class SingleThread2 implements Runnable{
private static int ticket = 100;
@Override
public void run() {
while (true) {
sellTicket();
}
}
public static synchronized void sellTicket() {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "第张票");
ticket -= 1;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
System.out.println(Thread.currentThread().getName() + "售罄");
}
}
}
public class Demo4 {
public static void main(String[] args) {
Thread thread1 = new Thread(new SingleThread2(), "淘票票");
Thread thread2 = new Thread(new SingleThread2(), "飞猪");
Thread thread3 = new Thread(new SingleThread2(), "美团");
thread1.start();
thread2.start();
thread3.start();
}
}
非静态成员方法实例:
package cn.ocean888;
class SingleThread implements Runnable{
private static int ticket = 100;
@Override
public void run() {
while (true) {
sellTicket();
}
}
public synchronized void sellTicket() {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "第张票");
ticket -= 1;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
System.out.println(Thread.currentThread().getName() + "售罄");
}
}
}
public class Demo3 {
public static void main(String[] args) {
SingleThread singleThread = new SingleThread();
Thread thread1 = new Thread(singleThread, "淘票票");
Thread thread2 = new Thread(singleThread, "飞猪");
Thread thread3 = new Thread(singleThread, "美团");
thread1.start();
thread2.start();
thread3.start();
}
}
总结
- 如果非static修饰,要保证执行的线程对象有且只有一个,因为锁对象就是当前线程对象
- 如果是static修饰,锁对象具有唯一性,多个线程使用的锁是同一个锁
Lock锁
Java提供了一个对于线程安全问题,加锁操作相对于同步代码块方法更加广泛
-
对象化操作
创建Lock构造方法
Lock lock = new ReentrantLock();
-
方法化操作
开锁:unlock();
加锁:lock();
package cn.ocean888;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class SingleThread3 implements Runnable{
private static int ticket = 100;
static Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
lock.lock();
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "第张票");
ticket -= 1;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
System.out.println(Thread.currentThread().getName() + "售罄");
break;
}
lock.unlock();
}
}
}
public class Demo5 {
public static void main(String[] args) {
SingleThread3 singleThread3 = new SingleThread3();
Thread thread1 = new Thread(singleThread3, "淘票票");
Thread thread2 = new Thread(singleThread3, "飞猪");
Thread thread3 = new Thread(singleThread3, "美团");
thread1.start();
thread2.start();
thread3.start();
}
}
三种加锁方式总结
-
一锁一线程,一所多线程问题
使用对应的锁操作对应的线程,考虑静态和非静态问题
同步方法和Lock锁使用
静态是一锁多目标,非静态是一锁一目标
-
涉及到同步问题时,要考虑好锁对象的选择问题
-
同步代码块,同步方法,Lock对象
守护线程
守护线程,也称之为后台线程,如果当前主线程崩掉,守护线程也会退出
守护线程一般用于:
- 自动下载
- 操作日志
- 操作监控
方法是通过线程对象
setDeamon(boolean flag);
true 为守护线程
false 缺省属性,正常线程
实例:
package cn.ocean888;
class BackUpThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Loading ..." + i + "%");
if (100 == i) {
System.out.println("Loading Complete ...");
}
}
}
}
public class Demo6 {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new BackUpThread());
// 当前线程作为一个守护线程使用
thread.setDaemon(true);
thread.start();
for (int i = 0; i < 50; i++) {
Thread.sleep(100);
System.out.println("主线程运行中...");
}
}
}
当主线程结束,守护线程也会结束
线程状态
6种状态
线程如果按照java.lang.Thread.State枚举方式来考虑,一共提供了6种状态
状态 | 导致状态的发生条件 |
---|---|
NEW(新建) | 线程刚刚被创建,没有启动,没有调用start方法 |
RUNNABLE(可运行) | 线程已经可以在JVM中运行,但是是否运行不确定,看当前线程是否拥有CPU执行权 |
BLOCKED(锁阻塞) | 当前线程进入一个同步代码需要获取对应的锁对象,但是发现当前锁对象被其他线程持有,当前线程会进入一个BLOCKED。如果占用锁对象的线程打开锁对象,当前线程持有对应锁对象,进入Runnable状态 |
WAITING(无限等待) | 通过一个wait方法线程进入一个无限等待状态,这里需要另外一个线程进行唤醒操作。进入无限等待状态的线程是无法自己回到Runnable状态,需要其他线程通过notify或者notifyAll方法进行唤醒操作 |
TIMED_WAITING(计时等待) | 当前线程的确是等待状态,但是会在一定时间之后自动回到Runnable状态,例如 Thread.sleep() 或者是Object类内的wait(int ms); |
TERMINATED(被终止) | 因为Run方法运行结束正常退出线程,或者说在运行的过程中因为出现异常导致当前线程GG思密达 |
TIMED_WAITING(计时等待)
-
Thread.sleep(int ms);
在对应线程代码块种,当前线程休眠指定的时间
-
Object类内 wait(int ms);
让当前线程进入一个计时等待状态
- 规定时间及时完毕,线程回到可运行状态
- 在等待时间内,通过其他线程或 notify 或者 notifyAll 唤醒
-
Sleep方法
- 调用之后休眠指定时间
- sleep方法必须执行在run方法内,才可以休眠线程
- sleep不会打开当前线程占用的锁对象
BLOCKED(锁阻塞)
线程中有锁存在,线程需要进入带有锁操作的同步代码,如果锁对象被别人持有,只能在锁外等待
锁阻塞状态的线程是否能够抢到锁对象有很多因素
- 优先级问题,非决定性因素
- CPU执行概率问题
后期高并发一定会存在多线程操作锁对象问题,如:秒杀,抢购等
后期可以通过队列方式解决
WAITING(无限等待)
当某一个线程被执行wait()方法,需要等待另外的一个线程进行唤醒操作
以下三个方法都是Object类内的方法:
- public void wait();
在哪一个线程中执行,就会让当前线程进入一个无限等待状态。- 所在线程进入无限等待状态
- 开启【锁对象】
- public void notify();
唤醒和当前锁对象有关的无限等待线程中的一个,随机选择- 唤醒一个无限等待状态线程
- 开启【锁对象】
- public void notifyAll();
唤醒所有和当前锁对象有关的无限等待线程- 唤醒所有线程
- 开启【锁对象】
- 线程进入锁对象抢占过程,就有可能进入一个锁阻塞状态
线程执行的所有状态分析图
线程通信
共享资源处理问题
实例:以生产者和消费者的角度考虑商品共享资源的处理
Demo.java
package cn.ocean888thread;
public class Demo1 {
public static void main(String[] args) {
Goods goods = new Goods("积木", 29, true);
Producer producer = new Producer(goods);
Custmor customer = new Custmor(goods);
new Thread(producer).start();
new Thread(customer).start();
/*
两个线程同时运行,一个线程进入线程代码块,同时加锁,运行结束
两个线程回到同一个起跑线,但是保障之前运行锅的线程,需要进行休眠操作
如果已经执行完成的,调用wait方法, 进入休眠状态、。
*/
}
}
Goods.java
package cn.ocean888thread;
public class Goods {
private String name;
private float price;
private boolean product;
public Goods() {
super();
}
public Goods(String name, float price, boolean product) {
super();
this.name = name;
this.price = price;
this.product = product;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
public boolean isProduct() {
return product;
}
public void setProduct(boolean product) {
this.product = product;
}
@Override
public String toString() {
return "Goods [name=" + name + ", price=" + price + ", product=" + product + "]";
}
}
Producer.java
package cn.ocean888thread;
public class Producer implements Runnable{
private Goods goods = null;
public Producer() {}
public Producer(Goods goods) {
this.goods = goods;
}
/*
* Thread线程代码块
*/
@Override
public void run() {
while (true) {
synchronized (goods) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 需要生产
if (goods.isProduct()) {
if (Math.random() > 0.5) {
goods.setName("手办");
goods.setPrice(99.0F);
} else {
goods.setName("摆台");
goods.setPrice(49.0F);
}
// 修改标记
goods.setProduct(false);
System.out.println("生产者生产了" + goods.getName() + "价格为:" + goods.getPrice());
// 唤醒消费者
System.out.println("唤醒消费者");
goods.notify();
} else {
System.out.println("生产者进入无限等待状态");
try {
goods.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
Custmor.java
package cn.ocean888thread;
public class Custmor implements Runnable{
private Goods goods = null;
public Custmor() {}
public Custmor(Goods goods) {
this.goods = goods;
}
@Override
public void run() {
while (true) {
synchronized (goods) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 可以购买
if (!goods.isProduct()) {
System.out.println("消费者购买了" + goods.getName() + "价格为" + goods.getPrice());
// 修改商品标记
goods.setProduct(true);
System.out.println("唤醒生产者");
goods.notify();
} else {
System.out.println("消费者进入无限等待状态");
try {
// 只对应当前线程
goods.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
}
运行结果:
生产者和消费者有条不紊,没有侵占共享资源
线程池
不管是继承Thread还是遵从Runnable接口, 都需要重写Run方法, 而且每一个线程对象有且只能执行一次, 之后就会被销毁
利用Runnable接口来提供执行目标, 而且借助于Thread执行线程
生活化实例
线程池 -> 可以容纳多个线程的容器
程序可以从线程池获取线程来完成目标代码, 同时也可以将线程归还给线程池, 省去了创建线程和销毁线程这样非常繁琐的操作
线程池任务执行参考图
线程池使用
public static ExecutorService newFixedThreadPool(int nThreads);
// 得到一个线程对象,初始化参数是要求当前线程池中的线程数
public Future submit(Runnable target);
// 从线程池中获取一个线程对象,并且执行给定的Runnable接口实现类对象作为执行目标
实例:
package cn.ocean888;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class MyThread1 implements Runnable {
@Override
public void run() {
System.out.println("Runnable 接口实现类,线程目标代码");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "测试程序");
}
}
public class Demo1 {
public static void main(String[] args) {
// 1.创建5个线程池对象
ExecutorService service = Executors.newFixedThreadPool(5);
// 2.创建一个MyThread1 Runnable接口实现类对象
MyThread1 target = new MyThread1();
// 3.使用线程池对象中的一个线程,指定目标代码
service.submit(target);
service.submit(target);
service.submit(target);
service.submit(target);
service.submit(target);
// 原有五个的基础上新增两个线程,这两个线程是等待己经存在的五个线程执行结束后出现空闲再使用
service.submit(target);
service.submit(target);
// 4.关闭线程池
// 一般不用关闭线程池,线程池会随着程序的退出而关闭
service.shutdown();
}
}
匿名对象方法使用
package cn.ocean888;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo2 {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(2);
service.submit(new Runnable() {
@Override
public void run() {
System.out.println("测试");
}
});
service.submit(new Runnable() {
@Override
public void run() {
System.out.println("测试");
}
});
}
}
比较繁琐,代码重复度太高
Lambda表达式
service.submit(() -> System.out.println(Thread.currentThread().getName()))
/* () -> System.out.println(Thread.currentThread().getName())
() 参数列表
-> 对应的方法体
箭头之后的代码就是正常语句
(参数列表) -> {代码语句}
*/
无参无返回值
package cn.ocean888;
interface Cook {
void cooking();
}
public class Demo3 {
public static void main(String[] args) {
// 1.匿名内部类形式
invokeCook(new Cook() {
@Override
public void cooking() {
System.out.println("one, two, three, four");
}
});
// 2.
invokeCook(() -> {
System.out.println("1, 2, 3, 4");
});
// 3.lambda表达式,推荐使用此方式
invokeCook(() -> System.out.println("Ocean"));
}
/**
* 执行Cook实现类对象方法
* @param cook
*/
public static void invokeCook(Cook cook) {
cook.cooking();
}
}
有参有返回值
package cn.ocean888;
import java.util.Arrays;
import java.util.Comparator;
public class Demo4 {
public static void main(String[] args) {
Person[] persons = {
new Person("ocean", 10),
new Person("alice", 8),
new Person("evil", 15),
};
// 1. public static <T> void sort(T[] a, Comparator<? super T> c)
//
Arrays.sort(persons, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
});
// 2.标准lambda表达式方法
Arrays.sort(persons, (Person o1, Person o2) -> {
return o2.getAge() - o1.getAge();
});
// 3.简版lambda表达式,可以省略数据类型,可以直接利用返回值
Arrays.sort(persons, (o1, o2) -> o2.getAge() - o1.getAge());
for (Person person : persons) {
System.out.println(person);
}
}
}
不考虑排序正反序的情况下,可以使用这种方式
实例2:
package cn.ocean888;
interface A {
float add(int num1, float num2);
}
public class Demo5 {
public static void main(String[] args) {
System.out.println(new A() {
@Override
public float add(int num1, float num2) {
return num1 + num2;
}
}.add(3, 4.3F));
// 数据类型可以省略,即使是不同数据类型
// 如果实现代码超过一行,可以在大括号里完成
test(5, 13.5F, (num1, num2) -> num1 + num2);
}
public static void test(int num1, float num2, A a) {
System.out.println(a.add(num1, num2));
}
}
Lambda表达式使用前提
-
有且只有一个缺省属性为public abstract 方法的接口,例如Comparator 接口,Runnable接口
-
使用lambda表达式有一个前后要求约束
方法的参数为接口类型,或者说局部变量使用调用方法,可以使用lambda
-
有且只有一个抽象方法的接口,称之为[函数式接口]