1、进程?线程?多任务?
电脑中运行着很多软件程序,如QQ、微信、浏览器、酷狗音乐、优酷视频等等,每个软件其实就是一个进程。而线程则是进程中的一个分支或者说现象就是独立的执行路径。一个进程中至少包括一个线程。线程可以理解为提高程序运行的效率,或者各司其职,如QQ中既可以同时打字聊天也可以语音,再比如高速路有三个车道,车辆就可以同时跑,充分利用道路,大大提高了通行效率。
2、线程的创建方式
常用的线程创建方式有Thread、Runnable、Callable、线程池。
官方对于Thread的描述:
2.1 Thread创建线程的步骤:
.自定义线程类继承Thread
.重写run()方法,编写线程执行程序体
.创建线程对象,调用start()方法启动线程。
2.1.1 MyThreadt测试
package com.thread;
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i <30 ; i++) {
System.out.println("子线程运行:"+i);
}
}
}
package com.test;
import com.thread.MyThread;
public class CommonTest {
public static void main(String[] args) {
//自定义的线程
MyThread myThread = new MyThread();
myThread.start();
//main 线程
for (int i = 0; i < 500; i++) {
System.out.println("主线程运行:" + i);
}
}
}
2.1.2 多线程下载图片
1、导入jar
2、创建下载类
3、自定义线程类
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>
package com.test;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
/**
* 自定义下载类
*/
public class WebDownload {
//下载方法
public void downloadFile(String url, String fileName) {
try {
FileUtils.copyURLToFile(new URL(url), new File(fileName));
} catch (IOException e) {
e.printStackTrace();
System.out.println("文件下载失败");
}
}
}
package com.thread;
import com.test.WebDownload;
//多线程同步下载图片
public class DownloadThread extends Thread {
//网络图片地址
private String url;
//文件名
private String name;
public DownloadThread(String url, String name) {
this.url = url;
this.name = name;
}
@Override
public void run() {
WebDownload webDownload = new WebDownload();
webDownload.downloadFile(url, name);
System.out.println("下载了文件,文件名:" + name);
}
public static void main(String[] args) {
DownloadThread downloadThread=new DownloadThread("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e","zhangjianing");
DownloadThread downloadThread2=new DownloadThread("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e","zhangjianing2");
DownloadThread downloadThread3=new DownloadThread("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e","zhangjianing3");
downloadThread.start();
downloadThread2.start();
downloadThread3.start();
}
}
下载成功
2.2 实现Runnable接口步骤
.自定义类实现Runnable接口
.实现接口中的run()方法,方法中编写线程执行体
.创建线程对象,调用start()方法,启动线程。
官方文档释义:
2.2.1 RunableDemo
package com.runnable;
//实现Runnable接口,重写run方法,
public class MyRunnable implements Runnable {
public void run() {//线程核心执行体
for (int i = 0; i < 20; i++) {
System.out.println("子线程运行:" + i);
}
}
}
public class CommonTest {
public static void main(String[] args) {
//创建runnable接口的实现类对象
MyRunnable myRunnable = new MyRunnable();
//本身Thread也是实现了Runnable接口的。
Thread thread = new Thread(myRunnable);
//调用start方法,启动线程
thread.start();
for (int i = 0; i < 50; i++) {
System.out.println("主线程运行:" + i);
}
}
继承Thread类和实现Runnable接口的区别
* 继承Thread类
1、子类继承Thread类具备多线程能力
2、启动线程:子类对象.start()
3、不建议使用:避免OOP单继承局限性。
* 实现Runable接口
1、实现接口Runnable具有多线程能力
2、启动线程,传入目标对象+Thread对象.start()
3、建议使用Runnable,避免了单继承的局限性,灵活方便,方便同一个对象被多个线程使用。
2.2.2 多线程实现买火车票
package com.runnable;
//实现Runnable接口,重写run方法,
public class MyRunnable implements Runnable {
//总票数
private int ticket = 100;
public void run() {//线程核心执行体
while (ticket>0) {
System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
//每一个线程卖出一张票,就减 一张票
ticket--;
}
}
}
public class CommonTest {
public static void main(String[] args) {
//线程1 模拟卖票
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
//线程2 模拟卖票
Thread thread2 = new Thread(myRunnable);
thread2.start();
//线程3 模拟卖票
Thread thread3 = new Thread(myRunnable);
thread3.start();
//线程4 模拟卖票
Thread thread4 = new Thread(myRunnable);
thread4.start();
}
控制台输出
Thread-0正在售卖第100张票
Thread-0正在售卖第99张票
Thread-0正在售卖第98张票
Thread-0正在售卖第97张票
Thread-0正在售卖第96张票
Thread-0正在售卖第95张票
Thread-0正在售卖第94张票
Thread-3正在售卖第100张票
Thread-1正在售卖第100张票
Thread-1正在售卖第99张票
Thread-1正在售卖第98张票
Thread-1正在售卖第97张票
Thread-1正在售卖第96张票
Thread-1正在售卖第95张票
Thread-1正在售卖第94张票
Thread-1正在售卖第93张票
Thread-1正在售卖第92张票
Thread-2正在售卖第100张票
Thread-1正在售卖第91张票
Thread-3正在售卖第99张票
Thread-0正在售卖第93张票
此时发现了问题 线程0 、线程 3 、线程2 都卖出了第100号票,这说明多个线程同时操作一个资源的情况下,线程不安全,有严重的数据问题。这个问题待会解决。
2.3 实现Callable接口步骤
1、实现Callable接口,需要返回值类型
2、重写call方法,需要抛出异常
3、创建目标对象
4、创建执行服务:ExecutorService es=new Executors.newFixedThreadPool(1);
5、提交执行:Future<Boolean> result=es.submit(1);
6、获取结果:boolean flag=result.get();
7、关闭服务:es.shutdownNow();
2.3.1 实现Callable接口多线程下载图片
package com.test;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
/**
* 自定义下载类
*/
public class WebDownload {
//下载方法
public void downloadFile(String url, String fileName) {
try {
FileUtils.copyURLToFile(new URL(url), new File(fileName));
} catch (IOException e) {
e.printStackTrace();
System.out.println("文件下载失败");
}
}
}
package com.callable;
import com.test.WebDownload;
import java.util.concurrent.Callable;
public class MyCallable implements Callable {
private String url;
private String name;
public MyCallable(String url, String name) {
this.url = url;
this.name = name;
}
public Boolean call() throws Exception {
//
WebDownload webDownload = new WebDownload();
//根据文件url和文件名 下载文件
webDownload.downloadFile(url,name);
return true;
}
}
public class CommonTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyCallable myCallable = new MyCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e", "zhangjianing2021");
MyCallable myCallable2 = new MyCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e", "zhangjianing2022");
MyCallable myCallable3 = new MyCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e", "zhangjianing2023");
//创建执行服务
ExecutorService es = Executors.newFixedThreadPool(3);
//提交执行
Future<Boolean> submit = es.submit(myCallable);
Future<Boolean> submit2 = es.submit(myCallable2);
Future<Boolean> submit3 = es.submit(myCallable3);
//获取结果
boolean r = submit.get();
boolean r2 = submit2.get();
boolean r3 = submit3.get();
//关闭服务
es.shutdown();
}
3、线程状态
线程状态一共分为创建、就绪、阻塞、运行、死亡五种状态。
//线程执行顺序
Thread thread = new Thread();
1、线程对象一旦创建就进入新生状态
2、调用start()方法,线程进行就绪状态,但是并不意味着立即调度执行。
3、当调用sleep()、wait()或者同步锁定时,线程进入阻塞状态。当阻塞解除后,
重新进入就绪状态,等待cpu调度。
4、进入运行状态,线程开始执行业务。
5、线程死亡。
3.1 线程核心方法
//更新线程的优先级
.setPriority(int newPriority);
//指定的毫秒数内让当前正在执行的线程休眠
.static void sleep(long millis);
//等待该线程终止/合并线程
.void join();
//暂停当前正在执行的线程对象,
//并执行其他线程 也叫线程礼让
.static void yield();
//中断线程,尽量不要使用这个方法。
.void interrupt();
//测试线程是否处于活动状态
.boolean isAlive()
3.1 停止/终止线程
目前不建议大家使用JDK官方提供的stop()、destroy()方法,文档表示此方法已废弃。
更多的建议让线程平滑的停下来,如设置标志位终止变量。
例:
public class StopRunnable implements Runnable {
//线程定义 停止标记
private boolean flag = true;
//对外提供停止线程方法
public void stop() {
this.flag = false;
}
public void run() {
int i =0;
//线程中判断 标记
while (flag) {
System.out.println(Thread.currentThread().getName()+"Run.....");
}
}
}
public static void main(String[] args) {
StopRunnable stopRunnable = new StopRunnable();
Thread thread = new Thread(stopRunnable);
thread.start();
for (int i = 0; i < 1000; i++) {
System.out.println("主线程:"+i);
if(i==900){
//调用stop方法 切换标识符,停止线程
stopRunnable.stop();
System.out.println(Thread.currentThread().getName()+":线程停止了");
}
}
}
3.2 线程休眠
1、sleep(long millils)指定当前线程阻塞的毫秒数
2、sleep存在异常InteruptedException;
3、sleep时间达到后,线程进入等待状态
4、sleep可以模拟网络延时,倒计时等。
5、每一个对象都有一个锁,但是sleep不会释放锁。
***售票模拟网路延时案例
public class Ticket implements Runnable {
//总票数
private static int ticket = 100;
public void run() {
while (ticket > 0) {
try {
//模拟延时2s
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "线程正在售卖第" + ticket-- + "张票");
}
}
public static void main(String[] args) {
Ticket ticket = new Ticket();
Thread thread = new Thread(ticket);
Thread thread2 = new Thread(ticket);
thread.start();
thread2.start();
}
}
**** 模拟倒计时案例
//模拟 倒计时Demo
public class CountdownTest implements Runnable {
private static int num = 10;
public void run() {
while (num > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("num>>>>>:" + num--);
}
}
public static void main(String[] args) {
CountdownTest countdownTest = new CountdownTest();
Thread thread = new Thread(countdownTest);
thread.start();
}
}
num>>>>>:10
num>>>>>:9
num>>>>>:8
num>>>>>:7
num>>>>>:6
num>>>>>:5
num>>>>>:4
num>>>>>:3
num>>>>>:2
Disconnected from the target VM, address: '127.0.0.1:12167', transport: 'socket'
num>>>>>:1
3.3 线程礼让
1、礼让线程,让当前正在执行的线程暂停,但是不阻塞。
2、将线程从运行的状态改为就绪状态
3、让cpu重新调度,礼让不一定能成功,看cpu心情。
线程礼让Demo
package com.demo;
//线程礼让 demo
public class YieldRunable implements Runnable {
public void run() {
System.out.println(Thread.currentThread().getName() + "线程开始执行");
Thread.yield();//礼让线程
System.out.println(Thread.currentThread().getName() + "线程停止执行");
}
public static void main(String[] args) {
YieldRunable yieldRunable = new YieldRunable();
Thread thread = new Thread(yieldRunable);
thread.setName("A");
Thread thread2 = new Thread(yieldRunable);
thread2.setName("B");
thread.start();
thread2.start();
}
}
3.4 Join合并线程
Join合并线程,待此行程执行完毕后,在执行其他线程,其他线程阻塞。
比如银行VIP,或者说插队。只有vip办理完业务后,普通用户才可以办业务。
合并线程Join 案例
package com.demo;
public class JoinRunnable implements Runnable {
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("Join>>>>>:" + i);
}
}
public static void main(String[] args) throws InterruptedException {
JoinRunnable joinRunnable = new JoinRunnable();
Thread thread = new Thread(joinRunnable);
thread.start();
for (int i = 0; i < 100; i++) {
if (i == 50) {
thread.join();//主线程main阻塞,直到vip线程执行完毕,再去执行mian线程
}
System.out.println("mian>>>>>>>>:" + i);
}
}
}
果然看控制台输出,当mian中的i=50时线程被阻塞,vip合并(插队)了线程,并执行完毕自己的业务。
mian>>>>>>>>:0
Join>>>>>:0
Join>>>>>:1
Join>>>>>:2
Join>>>>>:3
Join>>>>>:4
Join>>>>>:5
Join>>>>>:6
Join>>>>>:7
Join>>>>>:8
Join>>>>>:9
mian>>>>>>>>:1
Join>>>>>:10
Join>>>>>:11
Join>>>>>:12
Join>>>>>:13
Join>>>>>:14
mian>>>>>>>>:2
Join>>>>>:15
mian>>>>>>>>:3
Join>>>>>:16
mian>>>>>>>>:4
mian>>>>>>>>:5
mian>>>>>>>>:6
mian>>>>>>>>:7
mian>>>>>>>>:8
mian>>>>>>>>:9
mian>>>>>>>>:10
Join>>>>>:17
Join>>>>>:18
Join>>>>>:19
mian>>>>>>>>:11
mian>>>>>>>>:12
mian>>>>>>>>:13
mian>>>>>>>>:14
mian>>>>>>>>:15
mian>>>>>>>>:16
mian>>>>>>>>:17
mian>>>>>>>>:18
mian>>>>>>>>:19
mian>>>>>>>>:20
mian>>>>>>>>:21
mian>>>>>>>>:22
mian>>>>>>>>:23
mian>>>>>>>>:24
mian>>>>>>>>:25
mian>>>>>>>>:26
mian>>>>>>>>:27
mian>>>>>>>>:28
mian>>>>>>>>:29
mian>>>>>>>>:30
mian>>>>>>>>:31
mian>>>>>>>>:32
mian>>>>>>>>:33
mian>>>>>>>>:34
mian>>>>>>>>:35
mian>>>>>>>>:36
mian>>>>>>>>:37
mian>>>>>>>>:38
Join>>>>>:20
mian>>>>>>>>:39
Join>>>>>:21
mian>>>>>>>>:40
Join>>>>>:22
mian>>>>>>>>:41
Join>>>>>:23
Join>>>>>:24
Join>>>>>:25
Join>>>>>:26
Join>>>>>:27
Join>>>>>:28
Join>>>>>:29
Join>>>>>:30
Join>>>>>:31
Join>>>>>:32
Join>>>>>:33
Join>>>>>:34
Join>>>>>:35
Join>>>>>:36
Join>>>>>:37
mian>>>>>>>>:42
Join>>>>>:38
Join>>>>>:39
Join>>>>>:40
Join>>>>>:41
Join>>>>>:42
Join>>>>>:43
Join>>>>>:44
Join>>>>>:45
Join>>>>>:46
Join>>>>>:47
Join>>>>>:48
mian>>>>>>>>:43
Join>>>>>:49
Join>>>>>:50
Join>>>>>:51
Join>>>>>:52
Join>>>>>:53
Join>>>>>:54
Join>>>>>:55
Join>>>>>:56
Join>>>>>:57
mian>>>>>>>>:44
mian>>>>>>>>:45
mian>>>>>>>>:46
mian>>>>>>>>:47
mian>>>>>>>>:48
mian>>>>>>>>:49 *********************
Join>>>>>:58 *********************
Join>>>>>:....
Join>>>>>:998
Join>>>>>:999 *********************
mian>>>>>>>>:...
mian>>>>>>>>:98
mian>>>>>>>>:99
3.5 线程状态观察
Thread.State 线程状态。线程可以处于以下状态之一
== New ==
尚未启动的线程处于此状态
== RUNNABLE ==
在java虚拟机中执行的状态处于此状态
== BLOCKED ==
被阻塞等待监视器锁定的线程处于此状态
== WAITING ==
正在等待另一个线程执行特定动作的线程处于此状态
== TIMED WAITING ==
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
== TERMINATED ==
已退出的线程处于此状态。
一个线程可以在给定时间点处于一个状态,这些状态是不反映任何操作系统线程
状态的虚拟机状态。
线程状态案例Demo
package com.demo;
public class ThreadState implements Runnable {
public void run() {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("///");
}
public static void main(String[] args) throws InterruptedException {
ThreadState threadState = new ThreadState();
Thread thread = new Thread(threadState);
//观察状态 NEW
Thread.State state = thread.getState();
System.out.println(state);
//线程启动 观察启动后 RUN
thread.start();
state = thread.getState();
//Run 阶段
System.out.println(state);
//如果线程不停止,一直输出状态
while (state != Thread.State.TERMINATED) {
Thread.sleep(100);
//更新状态
state = thread.getState();
//
System.out.println(state);
}
}
}
3.6 线程优先级
1、Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,
线程调度器按照优先级决定应该调度哪个线程来执行。
2、线程的优先级用数字表示,范围从1~10
2.1 Thread.MIN_PRIORITY=1
2.2 Thread.MAX_PRIORITY=10
2.3 Thread.NORM_PRIORITY=5
使用一下方式改变或者获取优先级
... getPriority().setPriority(int xxx)
线程优先级案例Demo
package com.demo;
/**
* 线程优先级
*/
public class ThreadPriority implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "....>>>" + Thread.currentThread().getPriority());
}
public static void main(String[] args) {
//主线程默认优先级
System.out.println(Thread.currentThread().getName() + "....>>>" + Thread.currentThread().getPriority());
ThreadPriority threadPriority = new ThreadPriority();
Thread thread = new Thread(threadPriority);
Thread thread2 = new Thread(threadPriority);
Thread thread3 = new Thread(threadPriority);
Thread thread4 = new Thread(threadPriority);
Thread thread5 = new Thread(threadPriority);
Thread thread6 = new Thread(threadPriority);
//先设置优先级 然后启动
thread.start();
thread2.setPriority(1);
thread2.start();
thread3.setPriority(4);
thread3.start();
//MAX_PRIORITY =10
thread4.setPriority(Thread.MAX_PRIORITY);
thread4.start();
thread5.setPriority(-1);
thread5.start();
thread6.setPriority(11);
thread6.start();
}
}
控制台报错。此时说明线程优先级低只是意味着获得调度的概率低,
并不是优先级低就不会被调用,要看CPU的调度。
Thread-0....>>>5
Thread-1....>>>1
Thread-2....>>>4
Thread-3....>>>10
java.lang.IllegalArgumentException
at java.lang.Thread.setPriority(Thread.java:1089)
at com.demo.ThreadPriority.main(ThreadPriority.java:34)
3.7 守护线程(daemon)
1、线程分为用户线程和守护线程
2、虚拟机必须确保用户线程执行完毕
3、虚拟机不用等待守护线程执行完毕,
如后台记录操作日志、监控内存、垃圾回收等..
守护线程案例Demo
package com.demo;
/**
* 守护线程
*/
public class ThreadDaemon {
public static void main(String[] args) {
God god = new God();
Perople perople = new Perople();
Thread thread = new Thread(god);
//默认false表示是用户线程 正常的线程都是用户线程
thread.setDaemon(true);
//上帝启动守护线程
thread.start();
Thread thread2 = new Thread(perople);
//用户线程启动
thread2.start();
}
}
class God implements Runnable {
@Override
public void run() {
while (true) {
System.out.println("哦天哪 我的上帝,保佑着子民");
}
}
}
class Perople implements Runnable {
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("人们开心的 活着每一天");
}
System.out.println("====googbybe world ===");
}
}
3.8 并发
并发:同一个对象或者同一个资源被多个线程同时操作。如 抢票、两个银行同时取钱、共享打印机、或者在学校餐厅打饭等。
线程不安全的产生原因:
**由于同一个进程的多个线程共享同一块存储空间,在带来方便的同时,也带来
了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入
锁机制synchronized,当一个线程获得对象的排它锁,独占资源,其他线程
必须等待,使用后释放锁即可,存在以下问题
1、一个线程持有锁会导致其他所有需要此锁的线程挂起。
2、在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,
引起性能问题。
3、如果一个优先级高的线程等待一个优先级低的线程释放锁(例 一个厕所,
优先级高的只是小便一下,优先级低的却是拉肚子占着门插销资源,
只有优先级低的释放完锁,优先级高的才能去小便,可能尿了裤子哈)
会导致优先级导致,引起性能问题。
.
处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候我们就需要线程同步,线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池行成队列(相对于排队),等待前面线程使用完毕,下一个线程再使用。
#模拟并发下多线程购票不安全案例
//重现线程不安全问题
public class TicketRunnable implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":正在售卖第" + ticket-- + ":票");
}
}
public static void main(String[] args) {
TicketRunnable ticketRunnable = new TicketRunnable();
Thread thread = new Thread(ticketRunnable);
Thread thread2 = new Thread(ticketRunnable);
Thread thread3 = new Thread(ticketRunnable);
thread.start();
thread2.start();
thread3.start();
}
}
此时三个线程共享icket变量,并发下产生问题(卖出了同一张票,甚至有负票),如控制台打印
Thread-1:正在售卖第100:票
Thread-2:正在售卖第100:票
Thread-0:正在售卖第100:票
Thread-2:正在售卖第99:票
Thread-1:正在售卖第99:票
Thread-2:正在售卖第98:票
Thread-0:正在售卖第99:票
Thread-2:正在售卖第97:票
Thread-1:正在售卖第98:票
Thread-2:正在售卖第96:票
Thread-0:正在售卖第98:票
Thread-2:正在售卖第95:票
Thread-1:正在售卖第97:票
Thread-2:正在售卖第94:票
Thread-0:正在售卖第97:票
......................
Thread-2:正在售卖第-1:票
线程不安全的集合案例
public class UnsafeCollection {
public static void main(String[] args) {
//线程不安全的集合
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(() -> {
list.add(Thread.currentThread().getName());
}).start();
System.out.println(list.size());
}
}
}
控制台输出只有9996个。
9996
4 解决并发下线程不安全问题。
4.1 同步方法
1、由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们
只需要针对方法提出一套机制,这套机制就是synchronized关键字
语法 :public synchronized void method(int args){}
synchronized方法控制对"对象"的访问,也就是每个对象对应一把锁,
每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程被阻塞,
方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能
获得这个锁,继续执行。
同步的前提:
1、 必须要有两个或者两个以上的线程
2、必须是多个线程使用同一个锁。
同步方法弊端:
如果将一个大的方法声明为synchronized将会影响效率(多个线程需要判断锁,较为消耗资源)。
此时可以解决卖票问题
ublic class Ticket implements Runnable {
private static int ticket = 100;
public void run() {
buyTicket();
}
public synchronized void buyTicket() {
while (ticket > 0) {
try {
//模拟延时2s
//Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "线程正在售卖第" + ticket-- + "张票");
}
}
public static void main(String[] args) {
Ticket ticket = new Ticket();
Thread thread = new Thread(ticket);
Thread thread2 = new Thread(ticket);
Thread thread3 = new Thread(ticket);
Thread thread4 = new Thread(ticket);
thread.start();
thread2.start();
thread3.start();
thread4.start();
}
}
4.2 同步代码块
语法:
synchnronized(Obj){}
1、Obj称之为 ==同步监视器==锁对象
.对象如同锁,持有锁的线程可以在同步中进行。
没有持有锁的线程,即使获取到了CPU的执行权,也进不去,因为没有获取锁。
Obj可以是任何对象,但是强烈建议使用==共享资源==作为同步监视器。
所谓共享资源也就是涉及到增删改的对象,查询的话无所谓。
同步方法中无需指定同步监视器,因为同步方法中的同步监视器就是this,
也就是这个对象本身,或者.class
2、同步监视器执行过程
2.1 第一个线程访问,锁定同步监视器,执行业务逻辑
2.2 第二个线程访问,发现同步监视器锁定,无法访问
2.3 第一个线程执行完毕,解锁同步监视器,释放锁资源
2.4 第二个线程访问,发现没有锁,抢到了锁资源,锁定并访问
2.5
现在可以使用同步代码块解决 刚才线程不安全的集合问题
public class UnsafeCollection {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(() -> {
//锁住了所有线程共享的资源
synchronized (list) {
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
同理同步代码块可以解决售票不安全问题
public class TicketRunnable implements Runnable {
private int ticket = 100;
Object object = new Object();
@Override
public void run() {
while (true) {
synchronized (object) {
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":正在售卖第" + ticket-- + ":票");
}
}
}
}
public static void main(String[] args) {
TicketRunnable ticketRunnable = new TicketRunnable();
Thread thread = new Thread(ticketRunnable);
Thread thread2 = new Thread(ticketRunnable);
Thread thread3 = new Thread(ticketRunnable);
Thread thread4 = new Thread(ticketRunnable);
Thread thread5 = new Thread(ticketRunnable);
thread.start();
thread2.start();
thread3.start();
thread4.start();
thread5.start();
}
}
5 死锁
多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形,如 某一个同步代码块拥有两个以上对象的锁时,就有可能发生 死锁的问题。
5.1 死锁避免方式
产生死锁的四个必要条件
1、互斥条件:一个资源每次都只能被一个进程使用。
2、请求与保持条件:一个进程因请求资源而堵塞时,对已获得的资源保持不放。
3、不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺。
4、循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
所有说只要想办法破解其中任意一个或者多个条件,就可以避免死锁发生。
6 Lock锁
1、从JDK5.0开始,Java提供了更强大的线程同步机制--通过显示定义同步锁对象
来实现同步,同步锁使用Lock对象充当。
2、java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行
访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,
线程开始访问共享资源之前应先获得Lock对象。
3、ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性
和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,
可以显示加锁、释放锁。
/**
* lock锁解决线程安全问题
*/
public class ReentrantLockTest implements Runnable {
private ReentrantLock lock = new ReentrantLock();
private int ticket = 1000;
@Override
public void run() {
while (true) {
try {
lock.lock();
if (ticket > 0) {
try {
//Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
// while (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":正在售卖" + ticket-- + "张票");
// }
} else {
break;
}
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
ReentrantLockTest reentrantLockTest = new ReentrantLockTest();
Thread thread = new Thread(reentrantLockTest);
Thread thread2 = new Thread(reentrantLockTest);
Thread thread3 = new Thread(reentrantLockTest);
Thread thread4 = new Thread(reentrantLockTest);
thread.start();
thread2.start();
thread3.start();
thread4.start();
}
7 synchronized与Lock的区别
1、Lock锁时显示锁(手动开启和关闭锁),synchronized是隐试的,
出了作用域会自动释放。
2、Lock只有代码块锁,synchronized有代码块锁和方法锁
3、使用Lock锁,Jvm将花费较少的时间来调度线程,性能更好,有更好的扩展性
(提供更多的子类)
4、有限使用步骤
Lock>同步代码块(已经进入了方法体,分配了相应资源)>同步方法(在方法体之外)
9 线程协作(生产者消费者模式)
9.1 线程通信
应用场景:生产者和消费者问题
假如仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费。
如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止。
如果仓库中放着产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止。
9.2线程通信–分析
这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间
互相依赖,互为条件。
1、对于生产者,没有生产产品之前,要通知消费者等待,而生产者生产了产品之后,
有需要马上通知消费者消费。
2、对于消费者,在消费者之后,要通知生产者已经结束消费,需要生产新的产品
以供消费。
3、在生产者消费者问题中,仅仅有synchronized是不够的,
3.1 synchronized 可阻止并发更新同一个共享资源,实现了同步。
3.2 synchronized 不能用来实现不同线程之间的消息传递(通信)
9.3 == 线程通信方法==
java自带了几个方法来解决线程间的通信问题
1、wait() : 表示线程一直等待,直到其他线程通知,与sleep不同,会释放锁
2、wait(long timeout): 指定等待的毫秒数
3、notify(): 唤醒一个处于等待状态的线程
3、notifyAll(): 唤醒同一个对象上所有调用wait()方法的线程,优先级别高的
线程优先调度
他们都是父类Object的方法,所有都只能在同步方法或者同步代码块中使用,否则
会抛出IIIegalMonitorStateException
9.4 线程通信方式一 管程法
并发协作模型“生产者/消费者” -->管程法
生产者:负责生产数据的模块(可能是方法,对象,线程,进程)
消费者:负责处理数据的模块
缓冲区:消费者不能直接使用生产者的数据,他们之间有个缓冲区,
生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据
生产者/消费者模型 —>管程法案例
10 线程池
为什么使用线程池?
原因:经常创建和销毁、使用量特别大的资源,如并发情况下的线程,对性能影响很大。
解决思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。
可以
避免频繁创建销毁、实现重复利用。类似生活中的交通工具。
优点:
1、提高响应速度(减少了创建新线程的时间)
2、降低资源消耗(重复利用线程池中线程,不需要每次都创建)
3、便于线程管理
.corePoolSize:核心池的大小
.maximumPoolSize:最大线程数
.keepAliveTime:线程没有任务时最多保持多长时间后会终止
10.1 线程池使用
JDK5.0起提供了线程池相关API:ExcutorService和Executors
ExcutorService:真正的线程池接口,子类ThreadPoolExecutor
void execute(Runnable command):执行任务/命令,没有返回值,
一般用来执行Runnable
<T>Futrue<T>submit(Callable<T>task):执行任务,有返回值,一般用来
执行 Callable
void shutdown():关闭连接池
Executors:工具类、线程类的工厂类,用于创建并返回不同类型的线程池
10.1 线程池案例
public class ExecutorsTest {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
executorService.execute(new ThreadTest());
executorService.execute(new ThreadTest());
executorService.execute(new ThreadTest());
executorService.execute(new ThreadTest());
executorService.shutdown();
}
}
class ThreadTest implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}