15线程
目录
进程
1.进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。
2.进程是程序的一次执行过程中，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程。
什么是线程
1.线程由进程创建的，是进程的一个实体
2.一个进程可以拥有多个进程
其它相关概念
1.单线程：同一个时刻，只允许执行一个线程
2.多线程：同一个时刻，可以执行多个线程。如：一个QQ进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件
3.并发：同一个时刻，多个任务交替执行，造成一种"貌似同时"的错觉，简单的说，单核CPU实现的多任务就是并发。
4.并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。
创建线程的两种方式：
1.继承Thread类，重写run方法
2.实现Runnable接口，重写run方法
线程应用案例：
1继承Thread类
1.请编写程序，开启一个线程，该线程每隔1秒。在控制后台输出"喵喵，我是小猫"
2.对上题改进:当输出80次 喵喵，我是小猫，结束该线程
3.使用JConsole监控线程执行情况，并画出程序示意图。
点击查看代码
public class Thread01 {
public static void main(String[] args) throws InterruptedException {
//创建线程，可以当做线程使用
Cat cat = new Cat();
/**
* 源码解读：
* 1. public synchronized void start() {
* start0();
* }
*
* 2. start0();是本地方法，由JVM调用，次曾是C/C++实现
* 真正实现多线程的效果，是start0()，而不是run
* private native void start0();
*
* 3.
*/
cat.start();//启动线程→最终会执行cat的run方法
//cat.run();//run方法就是一个普通的方法，没有真正的启动一个线程，就会把run方法执行完毕，才继续向下执行
//说明：当main线程启动一个子线程 Thread-0，主线程不会阻赛，会继续执行
//这时，主线程和子线程是交替执行
System.out.println("主线程继续执行"+Thread.currentThread().getName());//名字main
for (int i = 0; i < 60; i++) {
System.out.println("主线程 i="+i);
//让主线程休眠
Thread.sleep(1000);
}
}
}
/**
* 1.当一个类继承了Thread类，该类就可以当做线程使用
* 2.我们会重写run方法，写上自己的业务代码
* 3.run Thread类 实现了 Runnable 接口的run 方法
*
* @Override
* public void run() {
* if (target != null) {
* target.run();
* }
* }
*/
class Cat extends Thread{
int count = 0;
@Override
public void run() {//重写run方法，写上自己的业务逻辑
while (true) {
//该线程每个1秒。在控制台输出"喵喵，我是小猫"
System.out.println("喵喵，我是小猫" + ++count +"线程名="+Thread.currentThread().getName());
//让该线程休眠1秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(count == 80){
break;//当times到80，退出while，这时线程也就退出了
}
}
}
}
2实现Runnable接口
请编写程序，该程序可以每隔1秒。在控制输出 hi ，当输出10伺候，自动退出。请使用实现Runnable接口的方式实现。[这里底层使用了设计模式(代理模式)]
点击查看代码
public class Thread02 {
public static void main(String[] args) {
Dog dog = new Dog();
//dog.start();//这里不能调用start
Thread thread = new Thread(dog);
thread.start();
Tiger tiger = new Tiger();//实现了Runnable
ThreadProxy threadProxy = new ThreadProxy(tiger);
Thread thread1 = new Thread(threadProxy);
thread1.start();
}
}
class Animal{}
class Tiger extends Animal implements Runnable{
@Override
public void run() {
System.out.println("老虎嗷嗷叫");
}
}
//线程代理类，模拟了一个极简的Thread类
class ThreadProxy implements Runnable{//可以把Proxy类当作 ThreadProxy
private Runnable target = null;//属性，类型是 Runnable
public ThreadProxy(Runnable target) {
this.target = target;
}
@Override
public void run() {
if(target != null){
target.run();//动态绑定(运行类型)
}
}
public void start(){
start0();//这个方法是真正实现多线程方法
}
public void start0(){
run();
}
}
class Dog implements Runnable{//通过实现Runnable接口，开发线程
int count = 0;
@Override
public void run() {//普通方法
while (true) {
System.out.println("小狗汪汪汪...hi"+(++count)+"\t"+Thread.currentThread().getName());
try {
//休眠
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10){
break;
}
}
}
}
说明：
1.java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能了。
2.java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程。
3多线程执行：
1.请编写一个程序，创建两个线程，一个线程每隔1秒输出"hello,world"，输出10次，退出，一个线程每隔1秒输出"hi",输出5次退出
点击查看代码
public class Thread03 {
public static void main(String[] args) {
T1 t1 = new T1();
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(new T2());
thread1.start();//启动线程0
thread2.start();//启动线程1
}
}
//每隔一秒输出hello world
class T1 implements Runnable{
int count = 0;
@Override
public void run() {
while (true) {
System.out.println("hello world"+(++count));
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(count == 10){
break;
}
}
}
}
//每隔两秒输出 hi
class T2 implements Runnable{
int count = 0;
@Override
public void run() {
while (true) {
System.out.println("hi"+(++count));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(count == 10){
break;
}
}
}
}
继承Thread VS 实现Runnable的区别
1.从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档可以看到Thread类本身就实现了Runnable接口start()→start0()
2.实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制
3.[售票系统]，编程模拟三个售票窗口100，分别使用继承Thread和实现Runnable方式，分析有什么问题。
点击查看代码
public class SellTicket {
public static void main(String[] args) {
// SellTicket01 sellTicket01 = new SellTicket01();
// SellTicket01 sellTicket02 = new SellTicket01();
// SellTicket01 sellTicket03 = new SellTicket01();
// sellTicket01.start();//启动售票
// sellTicket02.start();
// sellTicket03.start();
SellTicket02 sellTicket02 = new SellTicket02();
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
}
}
//使用Thread方式
class SellTicket01 extends Thread{
private static int ticketNum = 100;//让多个线程共享num
@Override
public void run() {
while (true) {
if(ticketNum <= 0){
System.out.println("售票结束");
break;
}
//休眠50毫秒，模拟售票时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票\t"+"剩余票数"+ --ticketNum);
}
}
}
//使用Runnable
class SellTicket02 implements Runnable{
private int ticketNum = 100;//让多个线程共享num
@Override
public void run() {
while (true) {
if(ticketNum <= 0){
System.out.println("售票结束");
break;
}
//休眠50毫秒，模拟售票时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票\t"+"剩余票数"+ --ticketNum);
}
}
}
线程终止：
基本说明
1.当线程完成任务后，会自动终止
2.还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
案例：
启动一个线程t，要求在main线程中去停止线程t。
点击查看代码
public class ThreadExit {
public static void main(String[] args) throws InterruptedException {
T t = new T();
t.start();
//如果希望main线程去控制t1线程的终止，必须可以修改loop
//让t1退出run方法，从而终止t1线程→通知方式
//让主线程休眠10秒，在通知t1线程退出
Thread.sleep(10000);
t.setLoop(false);
}
}
//启动一个线程t，要求在main线程中去停止线程t。
class T extends Thread{
int count = 0;
//设置一个控制变量
private boolean loop = true;
@Override
public void run() {
while (loop) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("T运行中"+(++count));
}
}
public void setLoop(boolean loop) {
this.loop = loop;
}
}
线程常用方法
常用方法第一组
1.setName：//设置线程名称，使之参数name相同
2.getName：//返回该线程的名称
3.start：//使该线程开始执行;Java虚拟机底层调用该线程的start0方法
4.run：//调用线程对象run方法
5.setPriority：//更改线程的优先级
6.getPriority：//获取线程的优先级
7.sleep：//在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
8.interrupt：//中断线程
注意事项和细节：
1.start底层会创建新的线程，调用run，run就是一个简单地方法调用，不会启动新线程
2.线程优先级的范围：
MIN_PRIORITY = 1; NORM_PRIORITY = 5; MAX_PRIORITY = 10;
3.interrupt：中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程
4.sleep：线程的静态方法，使当前线程休眠
点击查看代码
public class ThreadMethod01 {
public static void main(String[] args) throws InterruptedException {
//测试相关的方法
T t = new T();
t.setName("张三");
t.setPriority(Thread.MIN_PRIORITY);
t.start();//启动线程
System.out.println(t.getName());
//主线程打印5 hi,然后中断子线程的休眠
for (int i = 0; i <5 ; i++) {
Thread.sleep(1000);
System.out.println("hi"+i);
}
t.interrupt();//当执行到这里就会打断t线程的休眠
}
}
class T extends Thread{//自定义的线程类
@Override
public void run() {
for (int i = 0; i < 100; i++) {
//Thread.currentThread().getName()获取当前线程的名称
System.out.println(Thread.currentThread().getName()+"吃包子"+i);
}
try {
System.out.println(Thread.currentThread().getName()+"休眠中。。");
Thread.sleep(20000);//20秒休眠
} catch (InterruptedException e) {
//当线程执行到一个interrupt 方法时，就会catch一个异常，可以加入自己的业务代码
//interruptedException
System.out.println(Thread.currentThread().getName()+"被 interrupt了");
}
}
}
常用方法第二组：
1.yield：线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以不一定礼让成功。
2.join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务。
3.案例：main线程创建一个子线程，每隔1秒输出hello，输出20次，主线程每隔1秒，输出hi，输出20次。要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续。
点击查看代码
public class ThreadMethod02 {
public static void main(String[] args) throws InterruptedException {
T2 t2 = new T2();
t2.start();
for (int i = 1; i <=10; i++) {
Thread.sleep(1000);
System.out.println("主线程吃"+i+"个包子");
if(i==5){
System.out.println("让子线程先吃");
//join线程插队
t2.join();
//yield礼让，不一定成功
Thread.yield();
}
}
}
}
class T2 extends Thread{
@Override
public void run() {
for (int i = 1; i <=20; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程吃了"+i+"个包子");
}
}
}
练习：
1.主线程每隔1秒，输出hi，一共10次
2.当输出到hi5时，启动一个子线程(要求实现Runnable)，每隔1S输出hello，等该线程输出10次hello后，退出
3.主线程继续输出hi，直到主线程退出
点击查看代码
public class ThreadMethodExercise {
public static void main(String[] args) throws InterruptedException {
T3 t3 = new T3();
Thread thread = new Thread(t3);
for (int i = 1; i <= 10; i++) {
System.out.println("hi\t"+i);
if(i == 5){//判断主线程输出5次创建子线程
thread.start();//创建子线程
thread.join();//让子线程插队
System.out.println("子线程结束");
}
Thread.sleep(100);
}
System.out.println("主线程结束");
}
}
class T3 implements Runnable{
@Override
public void run() {
for (int i=1;i<=10;i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("hello\t"+i);
}
}
}
用户线程和守护线程：
1.用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
2.守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
3.常见的守护线程：垃圾回收机制
点击查看代码
public class ThreadMethod03 {
public static void main(String[] args) throws InterruptedException {
MyDaemonThread myDaemonThread = new MyDaemonThread();
//如果我们希望当main线程结束后，子线程自动结束，只需将子线程设为守护线程即可
myDaemonThread.setDaemon(true);
myDaemonThread.start();
for (int i = 1; i <= 10; i++) {
System.out.println("王辛苦的工作");
Thread.sleep(1000);
}
}
}
class MyDaemonThread extends Thread {
int count = 0;
@Override
public void run() {
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("马和宋快乐聊天。。。"+(++count));
}
}
}
线程的生命周期
JDK中用Thread.State枚举表示了线程的几种状态
public static enum Thread.State
extends Enum<Thread.State>线程状态。 线程可以处于以下状态之一：
NEW
尚未启动的线程处于此状态。
RUNNABLE
在Java虚拟机中执行的线程处于此状态。
BLOCKED
被阻塞等待监视器锁定的线程处于此状态。
WAITING
正在等待另一个线程执行特定动作的线程处于此状态。
TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
TERMINATED
已退出的线程处于此状态。
点击查看代码
public class ThreadState {
public static void main(String[] args) throws InterruptedException {
T t = new T();
t.start();
System.out.println(t.getName() +"状态"+t.getState());
while (State.TERMINATED != t.getState()){
System.out.println(t.getName() +"状态"+t.getState());
Thread.sleep(1000);
}
System.out.println(t.getName() +"状态"+t.getState());
}
}
class T extends Thread{
@Override
public void run() {
while (true) {
for (int i = 0; i < 10; i++) {
System.out.println("hi"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
}
}
线程同步机制：
1.在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
2.也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其它线程都不可以对这个内存地址进行操作，直到该线程完成操作，其它线程才能对该内存地址进行操作
具体方法-Synchroized
1.同步代码块Synchroized(对象){//得到对象的锁，才能操作同步代码块
//需要被同步代码;
}
2.Synchroized还可以放在方法声明中，表示整个方法-为同步方法
public Synchroized void m (String name){
//需要被同步的代码;
}
点击查看代码
public class SellTicket {
public static void main(String[] args) {
SellTicket04 sellTicket02 = new SellTicket04();
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
}
}
//实现Runnable接口，使用synchronized实现线程同步
class SellTicket04 implements Runnable{
private int ticketNum = 100;//让多个线程共享num
private boolean loop = true;
Object object = new Object();
//public synchronized static void m1(){}锁是加在SellTicket03.class
//2.如果在静态方法中，实现一个同步代码块
/*
synchronized (SellTicket04.class) {
System.out.println("m2");
}
*/
public synchronized static void m1(){
}
public static void m2(){
synchronized (SellTicket04.class) {
System.out.println("m2");
}
}
//1.public synchronized void sell(){}就是一个同步方法
//2.这时锁在 this对象
//3.也可以在代码块上写 synchronize，同步代码块
public /*synchronized*/ void sell(){//同步方法，在同一时刻，只能有一个线程来执行run方法
synchronized (/*this*/object) {
if(ticketNum <= 0){
System.out.println("售票结束");
loop = false;
return;
}
//休眠50毫秒，模拟售票时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票\t"+"剩余票数"+ --ticketNum);
}
}
@Override
public void run() {
while (loop){
sell();
}
}
}
互斥锁：
1.在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
2.每个对象都对应于一个可称为"互斥锁"的标记，这个标记用来保证在任意时刻，只能有一个线程访问该对象。
3.关键字Synchroized 来与对象的互斥锁练习。当某个对象用Synchroized修饰时，表明该对象在任意时刻只能有一个线程访问。
4.同步的局限性：导致程序的执行效率要降低
5.同步方法(非静态的)的锁可以是this，也可以是其它对象(要求是同一个对象)
6.同步方法(静态的)的锁为当前类本身。
注意事项和细节：
1.同步方法如果没有使用static修饰：默认锁对象为this
2.如果方法使用static修饰，默认锁对象：当前类.class
3.实现的落地步骤：
需要先分析上锁的代码
选择同步代码块或同步方法
要求多个线程的锁对象为同一个即可
点击查看代码
public class SellTicket {
public static void main(String[] args) {
SellTicket04 sellTicket02 = new SellTicket04();
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
}
}
class SellTicket01 extends Thread{
private static int ticketNum = 100;//让多个线程共享num
public void m1(){
synchronized (this){
System.out.println("hello");
}
}
@Override
public void run() {
while (true) {
if(ticketNum <= 0){
System.out.println("售票结束");
break;
}
//休眠50毫秒，模拟售票时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票\t"+"剩余票数"+ --ticketNum);
}
}
}
线程的死锁：
多个线程都占用了对方的锁资源，但不肯想让，导致了死锁，在编程是一定要避免死锁的发送。
点击查看代码
public class DeadLock {
public static void main(String[] args) {
DeadLockDemo A = new DeadLockDemo(true);
DeadLockDemo B = new DeadLockDemo(false);
B.setName("B线程");
B.start();
A.setName("A线程");
A.start();
}
}
class DeadLockDemo extends Thread {
static Object o1 = new Object();//保证多线程，共享一个对象，这里使用static
static Object o2 = new Object();
boolean flag;
public DeadLockDemo(boolean flag) {//构造器
this.flag = flag;
}
//业务逻辑分析
//1.如果flag为T，线程就会先得到/持有o1对象锁，然后尝试去获取o2对象锁
//2.如果线程A得不到o2对象锁，就会Blocked
//3.如果flag为F，线程B就会先得到/持有o2对象锁，然后尝试去获取o1对象锁
//4.如果线程B得不到o1对象锁，就会Blocked
public void run() {
if (flag) {
synchronized (o1) {//对象互斥锁，下面就是同步代码
System.out.println(Thread.currentThread().getName() + "进入1");
synchronized (o2) {//这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + "进入2");
}
}
} else {
synchronized (o2) {
System.out.println(Thread.currentThread().getName() + "进入3");
synchronized (o1) {//这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + "进入4");
}
}
}
}
}
释放锁
下面操作会释放锁：
1.当前线程的同步方法、同步代码块执行结束
案例：上厕所完事出来
2.当前现场在同步代码块、同步方法中遇到break、return。
案例：没有正常的完事，经理叫他修改bug，不得已出来
3.当前现场在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
案例：没有正常的完事，发现忘带纸，不得已出来
4.当前现场在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁
案例：没有正常完事，觉得需要酝酿下，所以出来等会儿再进去
下面操作不会释放锁：
1.线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
案例：上厕所，太困了，在坑位上眯了一会儿
2.线程执行同步代码块时，其它线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。
提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用
作业：
1编程题
1.在main方法中启动两个线程
2.第1个线程循环随机打印100以内的整数
3.直到第2个线程从键盘读取了Q命令
点击查看代码
public class Homework01 {
public static void main(String[] args) {
A a = new A();
B b = new B(a);
a.start();
b.start();
}
}
class A extends Thread{
private boolean loop = true;
@Override
public void run() {
//输出1~100的数字
while (loop){
System.out.println((int)(Math.random()*100+1));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("A线程退出");
}
public void setLoop(boolean loop) {
this.loop = loop;
}
}
class B extends Thread{
private A a;
Scanner scanner = new Scanner(System.in);
public B(A a){//构造器中，直接传入A类对象
this.a = a;
}
@Override
public void run() {
while (true) {
//接收用户的输入
System.out.println("请输入你的指令(Q)表示退出");
char key = scanner.next().toUpperCase(Locale.ROOT).charAt(0);
if(key == 'Q'){
a.setLoop(false);
System.out.println("B线程退出");
break;
}
}
}
}
2编程题
1.有2个用户分别从同一个卡上取钱(总额：10000)
2.每次都取1000，当余额不足时，就不能取款了
3.不能出现超取现象=》线程同步问题。
点击查看代码
public class Homework02 {
public static void main(String[] args) {
T money = new T();
new Thread(money).start();
new Thread(money).start();
}
}
//class T implements Runnable {
// private int ticketNum = 10000;
// private boolean loop = true;
//
// public synchronized void money(){//同步方法，在同一时刻，只能有一个线程来执行run方法
// if(ticketNum <= 0){
// System.out.println("余额不足，不能取款");
// loop = false;
// return;
// }
// ticketNum -= 1000;
// System.out.println("窗口" + Thread.currentThread().getName() + "取1000元\t" + "剩余余额" + ticketNum);
// //休眠1秒，模拟售票时间
// try {
// Thread.sleep(1000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// }
//
// @Override
// public void run() {
// while (loop) {
// money();
// }
// }
//}
class T implements Runnable {
private int ticketNum = 10000;
private boolean loop = true;
@Override
public void run() {
while (loop) {
//1.这里使用 synchronized 实现了线程同步
//2.当多个线程执行到这里时，就回去争夺 this对象锁
//3.哪个线程争夺到(获取)this对象锁，就执行 synchronized 代码块
//4.争夺不到this对象锁，就blocked，准备继续争夺
synchronized (this) {
if (ticketNum <= 0) {//判断余额是否充足
System.out.println("余额不足，不能取款");
loop = false;
return;
}
ticketNum -= 1000;
System.out.println("窗口" + Thread.currentThread().getName() + "取1000元\t" + "剩余余额" + ticketNum);
//休眠1秒，模拟售票时间
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
浙公网安备 33010602011771号