程序 进程 线程
● 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码。
● 进程((process)就是正在执行的程序,从Windows角度讲,进程是操作系统进行 资源分配的最小单位.
● 线程(thread)进程可进一步细化为线程,是一个进程内部的最小执行单元,是操 作系统进行任务调度的最小单元,隶属于进程
线程和进程的关系
● 一个进程可以包含多个线程,一个线程只能属于一个进程,线程不能脱离进程 而独立运行;
● 每一个进程至少包含一个线程(称为主线程);在主线程中开始执行程序, java 程序的入口main()方法就是在主线程中被执行的。
● 在主线程中可以创建并启动其它的线程;
● 一个进程内的所有线程共享该进程的内存资源。
创建线程
此程序非多线程!
public class Sample {
public void method1(String str){
System.*out.println(str);*
}
public void method2(String str){
method1(str);
}
public static void main(String[] args) {
Sample s = new Sample();
s.method2("hello!");
}
}
创建线程
● 继承Thread类的方式
● 在Java中要实现线程,最简单的方式就是扩展Thread类,重写其中的run方法,方法原型如下:
● Thread类中的run方法本身并不执行任何操作,如果我们重写了run方法,当线程启动时,它将执行 run方法。
继承方式和实现方式的联系与区别
【区别】
继承Thread: 线程代码存放Thread子类run方法中。
实现Runnable:线程代码存在接口的子类的run方法。
【实现Runnable的好处】
1)避免了单继承的局限性
2)多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处
理同一份资源。
package com.ff.javathread.day1.demo2;
/*
创建线程,在线程中写可以独立执行的任务代码
*/
public class MyThread extends Thread{
//run中写我们需要执行的任务代码
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
System.out.println("MyThread:"+i);
}
}
}
package com.ff.javathread.day1.demo2;
public class Test {
public static void main(String[] args) {
//在主线程中创建一个线程,并启动它
MyThread myThread = new MyThread();
//myThread.run(); 启动线程不能调用run(),就是普通的方法调用
myThread.start();//启动线程
for (int i = 0; i <1000 ; i++) {
System.out.println("main:"+i);
}
}
}
package com.ff.javathread.day1.demo3;
/*
好处:避免了单继承的局限,提高了扩展性
*/
public class MyThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("MyThread:"+i);
}
}
}
package com.ff.javathread.day1.demo3;
public class Test {
public static void main(String[] args) {
//线程要执行的任务
MyThread myThread = new MyThread();
//创建线程,并为线程指定执行任务
Thread t = new Thread(myThread);
t.start();
for (int i = 0; i <10000 ; i++) {
System.out.println("main:"+i);
}
}
}
线程优先级
● 事实上,计算机只有一个CPU,各个线程轮流获得CPU的使用权,才能
执行任务;
● 优先级较高的线程有更多获得CPU的机会,反之亦然;
● 优先级用整数表示,取值范围是1~10,一般情况下,线程的默认优先级
都是5,但是也可以通过setPriority和getPriority方法来设置或返回优
先级;
●调度策略
● 时间片
● 抢占式:高优先级的线程抢占CPU
●Java的调度方法
● 同优先级线程组成先进先出队列,使用时间片策略
● 对高优先级,使用优先调度的抢占式策略
● Thread类有如下3个静态常量来表示优先级
● MAX_PRIORITY:取值为10,表示最高优先级。
● MIN_PRIORITY:取值为1,表示最底优先级。
● NORM_PRIORITY:取值为5,表示默认的优先级。
Thread类中方法
package com.ff.javathread.day1.demo4;
public class MyThread implements Runnable{
//任务
@Override
public void run() {
for(int i=0;i<1000;i++){
//currentThread()获得当前线程,getName()获得线程的名称
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
package com.ff.javathread.day1.demo4;
public class Test {
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread t1 = new Thread(myThread,"t1");//创建线程对象,添加执行任务,并命名
t1.start();
Thread t2 = new Thread(myThread,"t2");
t2.start();
t1.setPriority(10);//设置优先,高优先级的执行优先权高(不是一直执行完)
t2.setPriority(1);
/*for (int i = 0; i <100 ; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}*/
System.out.println("=========="+t1.getPriority());//获得线程优先级
System.out.println("=========="+t2.getPriority());
}
}
package com.ff.javathread.day1.demo5;
public class MyThread implements Runnable{
//任务
@Override
public void run() {
for(int i=0;i<1000;i++){
/* try {
Thread.sleep(100);//sleep()让线程休眠指定的时间
} catch (InterruptedException e) {
e.printStackTrace();
}*/
//currentThread()获得当前线程,getName()获得线程的名称
if(i%10==0){
Thread.yield();//线程让步
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
package com.ff.javathread.day1.demo5;
public class Test {
public static void main(String[] args) throws InterruptedException {
MyThread myThread = new MyThread();
Thread t1 = new Thread(myThread,"t1");//创建线程对象,添加执行任务,并命名
t1.start();
/* t1.join();//等待该线程终止,其他线程进入到阻塞状态
Thread t2 = new Thread(myThread,"t2");//创建线程对象,添加执行任务,并命名
t2.start();*/
for (int i = 0; i <1000 ; i++) {
System.out.println("main线程"+i);
}
}
}
线程状态
线程的状态:
● 新建:当一个Thread类或其子类的对象被声明并创建时,新生的线程对
象处于新建状态
● **就绪:**处于新建状态的线程被start()后,将进入线程队列等待CPU时
间片,此时它已具备了运行的条件,只是没分配到CPU资源
● **运行:**当就绪的线程被调度并获得CPU资源时,便进入运行状态,run
()方法定义了线程的操作和功能
● **阻塞:**在某种特殊情况下,被人为挂起或执行输入输出操作时,让出
CPU并临时中止自己的执行,进入阻塞状态
● **死亡:**线程完成了它的全部工作或线程被提前强制性地中止或出现异常
导致结束
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vKTtjdt4-1627089666425)(C:\Users\何文强\AppData\Roaming\Typora\typora-user-images\1624968911990.png)]
线程的分类
Java中的线程分为两类:用户线程和守护线程
用个比较通俗的比如,任何一个守护线程都是整个JVM中所有非守护线程的保姆:
只要当前JVM实例中尚存在任何一个非守护线程没有结束,守护线程就全部工作;
只有当最后一个非守护线程结束时,守护线程随着JVM一同结束工作。
守护线程的作用是为其他线程的运行提供便利服务,守护线程最典型的应用就是 GC
(垃圾回收器),它就是一个很称职的守护者。
用户线程和守护线程两者几乎没有区别,唯一的不同之处就在于虚拟机的离开:如果
用户线程已经全部退出运行了,只剩下守护线程存在了,虚拟机也就退出了。 因为没
有了被守护者,守护线程也就没有工作可做了,也就没有继续运行程序的必要了
注意:设置线程为守护线程必须在启动线程之前,否则会跑出一个
IllegalThreadStateException异常。
守护线程:
package com.ff.javathread.day1.demo6;
import java.net.Socket;
/*
用户线程
*/
public class ThreadDemo1 extends Thread{
Socket socket;
@Override
public void run() {
for (int i = 0; i < 100; i++) {
/*try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
package com.ff.javathread.day1.demo6;
/*
守护线程
*/
public class ThreadDemo2 extends Thread{
@Override
public void run() {
while(true){
/*try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
System.out.println("我是守护线程,我在默默到的守护者你");
}
}
}
package com.ff.javathread.day1.demo6;
public class Test {
public static void main(String[] args) {
ThreadDemo1 userThread = new ThreadDemo1();
userThread.start();
ThreadDemo2 sh = new ThreadDemo2();
sh.setDaemon(true);//设置线程2为守护线程,必须在启动前设置
sh.start();
}
}
多线程的概念
● 多线程是指程序中包含多个执行单元,即在一个程序中可以同时运行多
个不同的线程来执行不同的任务,也就是说允许单个程序创建多个并行
执行的线程来完成各自的任务。
何时需要多线程
● 程序需要同时执行两个或多个任务。
● 程序需要实现一些需要等待的任务时,如用户输入、文件读写操作、
网络操作、搜索等。
● 需要一些后台运行的程序时。
多线程的优点
● 提高程序的响应.
● 提高CPU的利用率.
● 改善程序结构,将复杂任务分为对个线程,独立运行.
● 多线程的缺点
线程也是程序,所以线程需要占用内存,线程越多占用内存也越多;
多线程需要协调和管理,所以需要CPU时间跟踪线程;
线程之间对共享资源的访问会相互影响,必须解决竞用共享资源的问题;
线程同步
并发与并行
● 并行:多个CPU同时执行多个任务。比如:多个人同时做不同的事。
● 并发:一个CPU(采用时间片)同时执行多个任务。比如:秒杀、多个
人做同一件事。
多线程同步
● 多个线程同时读写同一份共享资源时,可能会引起冲突。所以引入线程“同步”机制,
即各线程间要有先来后到;
同步就是排队+锁:
● 几个线程之间要排队,一个个对共享资源进行操作,而不是同时进行操作;
● 为了保证数据在方法中被访问时的正确性,在访问时加入锁机制
模拟卖票
两个窗口分别售票,票数为10张
分别使用继承Thread和实现Runnable两种方式实现::
package day2.demo1;
/*
售票的线程
*/
public class TicketThread extends Thread{
static int num = 10;//票数 共享资源
static Object obj = new Object();//保证只有一个
@Override
public void run() {
while(true){
if(num>0){
print();
}else{
break;
}
}
}
/*
synchronized在修饰方法时,同步对象(锁), 默认是this 一旦创建多个线程对象(只针对继承Thread类的方式)
static修饰后,同步对象变为 线程类(类只有一个)
*/
public static synchronized void print(){
if(num>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"售出票:"+num);//0
//线程1再减之前 0
num--;
}
}
/* @Override
public void run() {
while(true){
//synchronized(同步锁,就是一个对象,但是要求对象只有一个)
synchronized(obj){
if(num>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"售出票:"+num);//0
//线程1再减之前 0
num--;
}else{
break;
}
}//同步代码块,执行完成后 同步对象(锁) 会自动释放
}
}*/
}
package day2.demo1;
public class Test {
public static void main(String[] args) {
TicketThread t1 = new TicketThread();
t1.setName("窗口1");
TicketThread t2 = new TicketThread();
t2.setName("窗口2");
t1.start();
t2.start();
}
}
package day2.demo2;
public class Test {
public static void main(String[] args) {
//创建出票任务
TicketThread ticketThread = new TicketThread();
//两个线程执行一个任务 num是只有一个的
Thread t1 = new Thread(ticketThread,"窗口1");
Thread t2 = new Thread(ticketThread,"窗口2");
t1.start();
t2.start();
}
}
package day2.demo2;
public class TicketThread implements Runnable{
int num = 10;//共享变量
@Override
public void run() {
while(true){
if(num>0){
print();
}else{
break;
}
}
}
//synchronized 默认同步锁对象是this
public synchronized void print(){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(num>0){
System.out.println(Thread.currentThread().getName()+":"+num);
num--;
}
}
● 确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁,哪个
线程获取了这把锁,才有权利访问该共享资源。
● 在Java代码中实现同步:
使用synchronized(同步监视器)关键字同步方法或代码块。
synchronized (同步监视器){
// 需要被同步的代码;
}
synchronized还可以放在方法声明中,表示整个方法,为同步方法。
例如:
public synchronized void show (String name){
// 需要被同步的代码;
}
同步监视器
同步监视器可以是任何对象,必须唯一,保证多个线程获得是同一个对象
(锁).
同步监视器的执行过程
1.第一个线程访问,锁定同步监视器,执行其中代码.
2.第二个线程访问,发现同步监视器被锁定,无法访问.
3.第一个线程访问完毕,解锁同步监视器.
4.第二个线程访问,发现同步监视器没有锁,然后锁定并访问.
● 一个线程持有锁会导致其他所有需要此锁的线程挂起;在多线程竞争下,加锁,
释放锁会导致比较多的上下文切换和调度延时,引起性能问题.
Lock(锁)
• Lock
• 从JDK 5.0开始,Java提供了更强大的线程同步机制-通过显式定义同步锁对象
来实现同步。同步锁使用Lock对象充当。
• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的
工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,
线程开始访问共享资源之前应先获得Lock对象。
• ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存
语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加
锁、释放锁.
package day2.demo3;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TicketThread implements Runnable{
int num = 10;//共享变量
Lock lock = new ReentrantLock();
@Override
public void run() {
while(true){
if(num>0){
print();
}else{
break;
}
}
}
public void print(){
//System.out.println("ssss");
try {
lock.lock();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(num>0){
System.out.println(Thread.currentThread().getName()+":"+num);
num--;
}
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();//在finally中释放 锁
}
//System.out.println("ssssssssssss");
}
}
package day2.demo3;
public class Test {
public static void main(String[] args) {
//创建出票任务
TicketThread ticketThread = new TicketThread();
//两个线程执行一个任务 num是只有一个的
Thread t1 = new Thread(ticketThread,"窗口1");
Thread t2 = new Thread(ticketThread,"窗口2");
t1.start();
t2.start();
}
}
线程死锁
死锁
不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃
自己需要的同步 资源,就形成了线程的死锁.
出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于
阻塞状态,无法继续.
案例:中国人和美国人吃饭
正常情况:
中国人:两个筷子
美国人:刀和叉
设计时考虑清楚锁的顺序,尽量减少嵌套的加锁交互数量。
特殊情况:
中国人: 一个筷子 一把刀
美国人:一个筷子 一把叉
package day2.demo4;
public class DieLock extends Thread{
static Object objA = new Object();
static Object objB = new Object();
boolean flag;
public DieLock(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if(flag){//线程1
synchronized (objA){
System.out.println("ifObjA");
synchronized (objB){
System.out.println("ifObjB");
}
}
}else{//线程2
synchronized (objB){
System.out.println("elseBbjB");
synchronized (objA){
System.out.println("elseObjA");
}
}
}
}
}
package day2.demo4;
public class Test {
public static void main(String[] args) {
DieLock dieLock1 = new DieLock(true);
DieLock dieLock2 = new DieLock(false);
dieLock1.start();
dieLock2.start();
}
}
线程通信
线程通讯指的是多个线程通过消息传递实现相互牵制,相互调度,即线程间的相
互作用。
涉及三个方法:
.wait一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器。
.notify一旦执行此方法,就会唤醒被wait的一个线程。如果有多个线程被wait,
就唤醒优先级高的那个。
.notifyAll一旦执行此方法,就会唤醒所有被wait的线程。
说明:
.wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方
法中。
.wait(),notify(),notifyAll()三个方法是定义在java.lang.Object类中
package day2.demo5;
public class PrintNumThread extends Thread {
static int num=0;
static Object obj = new Object();
@Override
public void run() {
while(true){
synchronized (obj){
obj.notify();//唤醒等待的线程,由于已经有线程持有锁了,也是不能进入到同步代码块
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(num<100){
num++;
System.out.println(Thread.currentThread().getName()+":"+num);
}else{
break;
}
try {
obj.wait();//线程等待,释放锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
package day2.demo5;
public class Test {
public static void main(String[] args) {
PrintNumThread p1 = new PrintNumThread();
PrintNumThread p2 = new PrintNumThread();
p1.start();
p2.start();
//System.out.println(Thread.currentThread().getName());
}
}
●经典例题:生产者/消费者问题
● 生产者(Productor)将产品放在柜台(Counter),而消费者(Customer)从柜台
处取走产品,生产者一次只能生产固定数量的产品(比如:1), 这时柜台中不能
再放产品,此时生产者应停止生产等待消费者拿走产品,此时生产者唤醒消费者来
取走产品,消费者拿走产品后,唤醒生产者,消费者开始等待.
package day2.demo6;
/*
柜台 只有一个
*/
public class Counter {
int num = 0;
/*
添加
*/
// 同步对象时this 就是同一个Counter对象
public synchronized void add(){
if(num==0){
num++;
System.out.println("生产者线程生产了一个商品");
this.notify();//唤醒消费者
}else{
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/*
取
*/
public synchronized void sub(){
if(num>0){
num--;
System.out.println("消费者线程消费了一个商品");
this.notify();
}else{
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
package day2.demo6;
/*
消费者线程
*/
public class CustomerThread extends Thread{
Counter counter;
public CustomerThread(Counter counter) {
this.counter = counter;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
counter.sub();
}
}
}
package day2.demo6;
/*
生产者
*/
public class ProductorThread extends Thread{
Counter counter;
public ProductorThread(Counter counter) {
this.counter = counter;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
counter.add();
}
}
}
package day2.demo6;
public class Test {
public static void main(String[] args) {
Counter c = new Counter();//两个线程共享的资源 柜台
ProductorThread p = new ProductorThread(c);
CustomerThread cu = new CustomerThread(c);
p.start();
cu.start();
}
}
新增创建线程方式
● 实现Callable接口与使用Runnable相比,Callable功能更强大些.
• 相比run()方法,可以有返回值
• 方法可以抛出异常
• 支持泛型的返回值
• 需要借助FutureTask类,获取返回结果
package day2.demo7;
import java.util.concurrent.Callable;
public class MyThread implements Callable<Integer> {
/*
可以有返回值,可以泛型定义
可以抛出异常
*/
@Override
public Integer call() throws Exception {
int num = 0;
num = 10;
for (int i = 0; i <10 ; i++) {
num+=i;
}
return num;
}
}
package day2.demo7;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test {
public static void main(String[] args) {
MyThread myThread = new MyThread();
FutureTask<Integer> futureTask = new FutureTask(myThread);//添加
Thread t = new Thread(futureTask);
t.start();
try {
Integer res = futureTask.get();
System.out.println(res);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}