就是应⽤程序在内存中分配的空间,也就是正在运⾏的程序,各个进程之间互 不⼲扰。同时进程保存着程序每⼀个时刻运⾏的状态。
1.2、线程(Thread):⼀个线程执⾏⼀个⼦任务,这样⼀个进程就包含了多个线程,每个线程负责⼀个单独的⼦任
务。
1.3、多线程:进程让操作系统的并发性 成为了可能,⽽线程让进程的内部并发成为了可能。
多进程的⽅式也可以实现并发,为什么我们要使⽤多线程?
- 进程间的通信⽐较复杂,⽽线程间的通信⽐较简单,通常情况下,我们需要使 ⽤共享资源,这些资源在线程间的通信⽐较容易。
- 进程是重量级的,⽽线程是轻量级的,故多线程⽅式的系统开销更⼩。
进程是⼀个独⽴的运⾏环境,⽽线程是在进程中执⾏的⼀个任务。他们两个本质的
区别是是否单独占有内存地址空间及其它系统资源(⽐如I/O):
- 进程单独占有⼀定的内存地址空间,进程间存在内存隔离,数据是分开 的,数据共享复杂但是同步简单,各个进程之间互不⼲扰;⽽线程共享所属进程占有的内存地址空间和资源,数据共享简单,但是同步复杂。
- 进程单独占有⼀定的内存地址空间,⼀个进程出现问题不会影响其他进程,不影响主程序的稳定性,可靠性⾼;⼀个线程崩溃可能影响整个程序的稳定性,可靠性较低。
- 进程单独占有⼀定的内存地址空间,进程的创建和销毁不仅需要保存寄存器和栈信息,还需要资源的分配回收以及⻚调度,开销较⼤;线程只需要保存寄存器和栈信息,开销较⼩。
继承Thread(重点)、实现Runnable接口(重点)、实现Callable接口
2.1、Thread类public class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我在上路...."+ i);
}
}
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
for (int i = 0; i < 2000; i++) {
System.out.println("我在下路...."+ i);
}
}
}
//调用start方法之后,线程才算启动
我在上路…0
我在下路…0
我在上路…1
我在下路…1
我在上路…2
我在下路…2
我在上路…3
练习Thread,实现多线程同步下载图片
package com.czb.xkk;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
public class MyThread2 extends Thread{
private String url; //网络图片地址
private String name; //保存文件夹
@Override
public void run() {
WebDownloder webDownloder = new WebDownloder();
webDownloder.downloder(url,name);
System.out.println("下载了文件名为:"+name);
}
public MyThread2(String name, String url) {
this.url = url;
this.name = name;
}
public static void main(String[] args) {
MyThread2 T1 = new MyThread2("阿尼亚1.jpg","https://biaoqingba.cn/wp-content/uploads/2022/05/c7cc5fa906fc7b1.jpeg");
MyThread2 T2 = new MyThread2("阿尼亚2.jpg","https://biaoqingba.cn/wp-content/uploads/2022/05/c7cc5fa906fc7b1.jpeg");
MyThread2 T3 = new MyThread2("阿尼亚3.jpg","https://biaoqingba.cn/wp-content/uploads/2022/05/c7cc5fa906fc7b1.jpeg");
T1.start();
T2.start();
T3.start();
}
}
class WebDownloder{
//下载方法
public void downloder(String url,String name){
try {
FileUtils.copyURLToFile(new URL(url),new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("IO异常,downloder方法出现问题");
}
}
}
下载了文件名为:阿尼亚2.jpg
下载了文件名为:阿尼亚1.jpg
下载了文件名为:阿尼亚3.jpg
避免单继承局限性,灵活方便,方便多个线程操作同一个对象
package com.czb.xkk;
public class MyThread3 implements Runnable{
@Override
public void run()
{
for (int i = 0; i < 20; i++) {
System.out.println("run方法"+ i);
}
}
public static void main(String[] args) {
new Thread(new MyThread3()).start();//和继承Thread类主要的不同点
for (int i = 0; i < 200; i++) {
System.out.println("main方法"+ i);
}
}
}
修改上面代码利用实现Runnable方法下载图片:
new Thread(T1).start();
new Thread(T2).start();
new Thread(T3).start();
package com.czb.xkk;
//经典抢票问题
public class MyThread4 implements Runnable{
private int tickets = 1;
@Override
public void run() {
while(true){
if(tickets>=100){
break;
}
tickets++;
//获取当前线程名字
System.out.println(Thread.currentThread().getName()+"拿到了第"+tickets +"票");
}
}
public static void main(String[] args) {
MyThread4 myThread4 = new MyThread4();
new Thread(myThread4,"小明").start();//三个线程
new Thread(myThread4,"小红").start();
new Thread(myThread4,"黄牛").start();
}
}
//出现了线程安全问题
黄牛拿到了第4票
小明拿到了第4票
小红拿到了第4票
黄牛拿到了第5票
小明拿到了第6票
小红拿到了第7票
小明拿到了第8票
2.3、实现Callable接口
//方式一:使用线程池的方式 //需要返回值 public class TestCallable implements Callable3、静态代理模式{} //重写call方法 //创建执行服务 //可以抛异常 ExecutorService ser = Executors.newFixedThreadPool(3); //提交执行 Future result1 = ser.submit(T1); Future result2 = ser.submit(T2); Future result3 = ser.submit(T3); //获取结果 boolean r1 = result1.get(); boolean r2 = result2.get(); boolean r3 = result3.get(); //关闭服务 ser.shutdownNow(); //方式二:使用FutureTask执行 FutureTask futuretask= new FutureTask (T1); FutureTask futuretask1= new FutureTask (T2); FutureTask futuretask2= new FutureTask (T3); new Thread(futuretask).start(); new Thread(futuretask1).start(); new Thread(futuretask2).start(); //可以通过futuretask得到运行结果 futuretask.get();
//层层调用,真实对象和代理对象实现同一个接口
//好处
//代理对象可以做真实对象做不了的事情,
//真实对象专注自己的事情
package com.czb.xkk.Proxy;
public class StaticProxy {
public static void main(String[] args) {
new proxy(new you()).HappyMarry();
}
}
interface Marry{
void HappyMarry();
}
//真实角色
class you implements Marry{
@Override
public void HappyMarry() {
System.out.println("我们要结婚啦!");
}
}
class proxy implements Marry{
private Marry target;
//代理--》真实对象
public proxy(Marry target) {
this.target = target;
}
@Override
public void HappyMarry() {
before();
this.target.HappyMarry();
after();
}
private void after() {
System.out.println("洞房花烛!");
}
private void before() {
System.out.println("布置婚房!");
}
}
4、Lamda表达式
函数式接口的定义:
- 任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。
比如:
public interface Runnable{
public abstract void run();
}
- 对于函数式接口,可以通过lamda表达式来创建该接口的对象。
package com.czb.xkk.TestLamda;
//层层简化
public class Teat1 {
//1、静态内部类
static class Like2 implements iLike{
@Override
public void lamda() {
System.out.println("我爱lamda2");
}
}
public static void main(String[] args) {
iLike like;
new Like().lamda();
like.lamda();
//2、局部内部类
class Like3 implements iLike{
@Override
public void lamda() {
System.out.println("我爱lamda3");
}
}
new Like3().lamda();
//3、匿名内部类,没有类名只能借助接口名或者父类实现
new iLike(){
@Override
public void lamda() {
System.out.println("我爱lamda4");
}
}.lamda();
//4、lamda简化,iLike只有一个方法
iLike like = ()->{
System.out.println("我爱lamda5");
};
like.lamda();
}
}
interface iLike{
void lamda();
}
class Like implements iLike{
@Override
public void lamda() {
System.out.println("我爱lamda");
}
}
//简化模式,不需要实现类,直接使用接口
package com.czb.xkk.TestLamda;
public class Teat1 {
public static void main(String[] args) {
iLike like;
//简化1,参数类型
like = (a)->{
System.out.println("我爱lamda5"+a);
};
like.lamda();
//简化2,去掉括号,没有参数不能去括号
like = a->{
System.out.println("我爱lamda5"+a);
};
like.lamda(521);
//简化3,去掉大括号,只适用于大括号里面只有一行代码的情况
like = a->System.out.println("我爱lamda5"+a);
like.lamda(521);
}
}
interface iLike{
void lamda(int a);
}
5、对线程的操作
5.1、线程停止
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PfK2jb3d-1655867474087)(C:UsersDIYAppDataRoamingTyporatypora-user-imagesimage-20220621151205012.png)]
方法:
setPriority(int newPriority) //更改线程优先级
static void sleep(long mills) //线程休眠
Thread.sleep(200);
void join() //等待该线程终止
static void yield() //暂停执行当前线程,并执行其他线程
void interrupt() //中断线程,不要使用
boolean isAlive() //测试线程是否处于活动状态
package com.czb.xkk.ThreadMethod;
public class TestStop implements Runnable{
private Boolean flag = true;
@Override
public void run() {
int i = 0;
while(flag){
System.out.println("Thread..."+i++);
}
}
public void stop(){
this.flag = false;
}
public static void main(String[] args) {
TestStop testStop = new TestStop();
new Thread(testStop).start();
for (int i = 0; i < 1000; i++) {
System.out.println("线程"+i);
if(i==888){
testStop.stop();
System.out.println("分线程停止"+i);//TestStop线程停止,主线程继续运行
}
}
}
}
5.2、线程休眠
package com.czb.xkk.ThreadMethod;
public class TestSleep {
public static void tenDown() throws InterruptedException {
int time = 10;
while (true){
Thread.sleep(1000);
System.out.println(time--);
if(time<=0){break;}
}
}
public static void main(String[] args) {
try {
tenDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
5.3、线程暂停yield
package com.czb.xkk.ThreadMethod;
import com.czb.xkk.MyThread;
public class TestYield {
public static void main(String[] args) {
MyYield myYield = new MyYield();
Thread thread = new Thread(myYield,"a");
Thread thread2 = new Thread(myYield,"b");
thread.start();
thread2.start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程正在执行");
Thread.yield();//礼让,不一定成功
System.out.println(Thread.currentThread().getName()+"线程正在执行");
}
}
a线程正在执行
b线程正在执行
a线程正在执行
b线程正在执行
5.4、线程强制执行
package com.czb.xkk.ThreadMethod;
public class JoinTest implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("vip来啦"+i);
}
}
public static void main(String[] args) throws InterruptedException {
JoinTest joinTest = new JoinTest();
Thread thread = new Thread(joinTest);
thread.start();
for (int i = 0; i < 100; i++) {
if(i==66){
thread.join();//JoinTest分线程执行,待分线程执行结束才会执行main线程
}
System.out.println("main"+i);
}
}
}
5.5、线程状态
-
**初始(NEW):**新创建了一个线程对象,但还没有调用start()方法。
-
**运行(RUNNABLE):**Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“运行”。线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取CPU的使用权,此时处于就绪状态(ready)。就绪状态的线程在获得CPU时间片后变为运行中状态(running)。
-
**阻塞(BLOCKED):**表示线程阻塞于锁。
-
**等待(WAITING):**进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
-
**超时等待(TIMED_WAITING):**该状态不同于WAITING,它可以在指定的时间后自行返回。终止(TERMINATED):表示该线程已经执行完毕。
-
package com.czb.xkk.ThreadMethod; public class TestState { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(()->{ for (int i = 0; i < 10; i++) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); System.out.println(thread.getState());//new thread.start(); System.out.println(thread.getState());//run while(thread.getState()!=Thread.State.TERMINATED){ Thread.sleep(100); System.out.println(thread.getState());//TIMED_WATTING、TERMINATED一旦进入死亡状态就不能再次启动了 } } }
优先级用数字表示,范围从1-10,优先级较高不一定会优先执行
//三个常量 Thread.MIN_PRIORITY = 1; Thread.MAX_PRIORITY = 10; Thread.NORM_PRIORITY = 5; //方法 getPriority(); setPriority();
package com.czb.xkk.ThreadMethod;
public class TestPriority {
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName()+"优先级为"+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread T1 = new Thread(myPriority);
Thread T2 = new Thread(myPriority);
Thread T3 = new Thread(myPriority);
Thread T4 = new Thread(myPriority);
T2.setPriority(1);
T3.setPriority(4);
T4.setPriority(Thread.MAX_PRIORITY);
T1.start();
T2.start();
T3.start();
T4.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"优先级为"+Thread.currentThread().getPriority());
}
}
6、线程安全问题
**并发:**同一个对象被多个线程同时操作。
线程同步(synchronized)实际是一种等待机制。
不安全的例子:经典抢票问题!银行取款问题!
6.1、同步方法:- synchronized关键字,包括synchronized方法和synchronized块。
//同步方法,给每个对象加了一把锁
public synchronized void method(){}
//缺点:影响效率
-
同步块:
synchronized(obj){} //obj称为同步监视器,可以为任何对象 //同步方法无需指定同步监视器
//同步方法
public class SafeTd {
public static void main(String[] args) {
BuyTickets buyTickets = new BuyTickets();
Thread t1 = new Thread(buyTickets,"小明");
Thread t2 = new Thread(buyTickets,"小红");
Thread t3 = new Thread(buyTickets,"黄牛");
t1.start();
t2.start();
t3.start();
}
}
class BuyTickets implements Runnable{
private int tickets = 100;
@Override
public synchronized void run() { //在买票方法中添加synchronized关键字,实现同步
while(true){
if(tickets<=0){
break;
}
System.out.println(Thread.currentThread().getName()+"买到了第"+tickets--+"张票");
}
}
}
//同步块
class BuyTickets implements Runnable{
private int tickets = 100;
Object obj = new Object();
@Override
public void run() {
synchronized (obj){
while(true){
if(tickets<=0){
break;
}
System.out.println(Thread.currentThread().getName()+"买到了第"+tickets--+"张票");
}
}
}
}
6.2、死锁
指两个线程或多个线程都在等待对方释放资源而停止执行的情况。某一个同步块同时拥有“两个以上对象的锁”时,就有可能产生“死锁”现象。
package com.czb.xkk.SafeThread;
public class DeadLock {
public static void main(String[] args) {
Makeup makeup = new Makeup(0,"灰姑娘");
Makeup makeup1 = new Makeup(1,"白雪公主");
makeup.start();
makeup1.start();
}
}
class LipStick{
}
class Mirror{
}
class Makeup extends Thread{
static LipStick lipStick = new LipStick();
static Mirror mirror = new Mirror();
int choice;
String girlName;
Makeup(int choice,String girlName){
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void makeup() throws InterruptedException {
if(choice==0){
synchronized (lipStick){
System.out.println(this.girlName+"获得口红");
Thread.sleep(1000);
synchronized (mirror){
System.out.println(this.girlName+"获得镜子");
}
}
}else{
synchronized (mirror){
System.out.println(this.girlName+"获得镜子");
Thread.sleep(2000);
synchronized (lipStick){
System.out.println(this.girlName+"获得口红");
}
}
}
}
}
灰姑娘获得口红
白雪公主获得镜子
出现死锁现象
解决方法:
synchronized (mirror){
System.out.println(this.girlName+"获得镜子");
}
放到上一个锁的外面,保证一个代码块只有一把锁。
灰姑娘获得口红
白雪公主获得镜子
白雪公主获得口红
灰姑娘获得镜子
6.3、Lock锁
ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁。(可重入锁)
package com.czb.xkk;
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
TestLock2 testLock2 = new TestLock2();
new Thread(testLock2,"李华").start();
new Thread(testLock2,"黄牛").start();
}
}
class TestLock2 implements Runnable{
private int tickets = 10;
//定义Lock锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
lock.lock();
try{
while (true) {
if (tickets <= 0) {
break;
} else {
System.out.println(Thread.currentThread().getName() + "获得了第" + tickets-- + "张票");
}
}
}finally{
lock.unlock();//解锁
}
}
}
出现的问题:
new了两个TestLock2类的变量
TestLock2 testLock1 = new TestLock2();
TestLock2 testLock2 = new TestLock2();
new Thread(testLock1,"李华").start();
new Thread(testLock2,"黄牛").start();
导致还会出现线程安全问题。
6.4、线程协作
6.4.1、线程之间通信的方法:
| 方法名 | 作用 |
|---|---|
| wait() | 表示线程一直等待,直到其他线程通知,与sleep不同,wait会释放锁 |
| wait(long timeout) | 指定等待的毫秒数 |
| notify() | 唤醒一个处于等待的线程 |
| notifyAll | 唤醒同一个线程上所有的调用了wait()方法的线程,优先级高的线程优先调度 |
注意:以上都是Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常。
6.4.2、并发的消费者生产者模式: 解决方法一:管程法:加入缓冲区,生产者将数据放入缓冲区,消费者从缓冲区拿出数据。
package com.czb.xkk;
import java.awt.*;
//测试生产者消费者问题1:管程法,加入缓冲区
public class ProductConsumer {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Product(container).start();
new Consumer(container).start();
}
}
class Product extends Thread{
SynContainer container;
public Product(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 1; i < 100; i++) {
System.out.println("生产了"+ i +"只鸡");
container.push(new Chicken(i));
}
}
}
class Consumer extends Thread{
SynContainer container;
public Consumer(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 1; i < 100; i++) {
System.out.println("消费了"+container.pop().id+"只鸡");
container.pop();
}
}
}
class Chicken {
int id;
public Chicken(int id) {
this.id = id;
}
}
class SynContainer{
Chicken [] chickens=new Chicken[10];
int count=0;
//生产者生产
public synchronized void push(Chicken chicken) {
while (count == chickens.length) {
try {
//生产满了,生产等待
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//没满就继续生产
chickens[count] = chicken;
count++;
//唤醒当前等待的线程,通知消费者消费
this.notifyAll();
}
//消费者消费
public synchronized Chicken pop() {
while (count == 0) {
try {
//产品空缺,消费等待
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//存在产品,继续消费
count--;
Chicken chicken = chickens[count];
//通知生产者生产
this.notifyAll();
return chicken;
}
}
解决方法二:
package com.czb.xkk;
//测试生产者消费者问题2:信号灯法,通过标志位解决
public class Test{
public static void main(String[] args) {
TV tv = new TV();
new Player(tv).start();
new Watcher(tv).start();
}
}
//生产者-->演员
class Player extends Thread {
TV tv;
public Player(TV tv) {
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
if (i % 2 == 0) {
this.tv.play("胸口碎大石");
} else {
this.tv.play("借尸还魂");
}
}
}
}
//消费者-->观众
class Watcher extends Thread {
TV tv;
public Watcher(TV tv) {
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
tv.watch();
}
}
}
//产品-->节目
class TV {
//演员表演,观众等待 T
//观众观看,演员等待 F
String voice; // 表演的节目
boolean flag = true;
//表演
public synchronized void play(String voice) {
if (!flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("演员表演了:" + voice);
//通知观众观看
this.notifyAll();
this.voice = voice;
this.flag = !this.flag;
}
//观看
public synchronized void watch() {
if (flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("观看了:" + voice);
//通知演员表演
this.notifyAll();
this.flag = !this.flag;
}
}
6.5、线程池
在并发的情况下,会提升性能,便于线程管理。
线程池接口:ExecutorService
package com.czb.xkk;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestPool {
public static void main(String[] args) {
//创建线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//执行
service.execute(new MyThread1());
service.execute(new MyThread1());
service.execute(new MyThread1());
//关闭连接
service.shutdown();
}
}
class MyThread1 implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
要是世界也这么简单就好了!



