java 多线程 总结 案例

Study stu = new Study();

new Thread(stu).start();

//外部改变该标识

for (int i = 0; i < 100; i++) {

if(i==50){//外部干涉

stu.stop();

}

System.out.println(“main…”+i);

}

}

}

class Study implements Runnable{

//1）线程类中 定义 线程体使用的标识

private boolean flag =true;

@Override

public void run() {

//2）线程提使用该标识

while(flag){

System.out.println(“Study thread …”);

}

}

//3）、对外提供方法改变该标识

public void stop(){

this.flag = false;

}

}

五：阻塞

IsAlive() 判断线程是否还活着，既线程是还未终止

getPriority()获得线程的优先级数值

setPriority() 设置线程的优先级数值

setName()给线程一个名字

getName()取得线程的名字

currentThread()取得当前正在运行的线程对象也就是取得自己本身

阻塞：join yield  sleep(重点)

1、Join:合并线程

package com.org.status;

/**

• join:合并线程

• @author lyy

*/

public class JoinDemo01 extends Thread {

public static void main(String[] args) throws InterruptedException {

JoinDemo01 join = new JoinDemo01();

Thread t = new Thread(join);//新增

t.start();//就绪

//cpu调度运行

for (int i = 0; i < 100; i++) {

if(50 == i){

t.join();//main阻塞

}

System.out.println(“main…”+i);

}

}

@Override

public void run() {

for (int i = 0; i < 100; i++) {

System.out.println(“join…”+i);

}

}

}

2、Yield：暂停自己的线程

package com.org.status;

import javax.sound.midi.Synthesizer;

public class YieldDemo01 extends Thread{

public static void main(String[] args) {

YieldDemo01 yield = new YieldDemo01();

Thread t = new Thread(yield);//新生

t.start();//就绪

//cpu调度运行

for (int i = 0; i < 100; i++) {

if(i%20 == 0){

//暂停本线程main

Thread.yield();

}

System.out.println(“main…”+i);

}

}

@Override

public void run() {

for (int i = 0; i < 100; i++) {

System.out.println(“yield…”+i);

}

}

}

3、Sleep():休眠，不释放锁

1)、时间相关（倒计时）

package com.org.status;

import java.text.SimpleDateFormat;

import java.util.Date;

/**

• 倒计时

• 1、倒数10个数，一秒内打印一个

• 2、倒计时

• @author lyy

*/

public class SleepDemo01 {

public static void main(String[] args) throws InterruptedException {

Date endTime = new Date(System.currentTimeMillis() + 10*1000);

long end = endTime.getTime();

while(true){

//输出

System.out.println(new SimpleDateFormat(“mm:ss”).format(endTime));

//构建下一秒的时间

endTime = new Date(endTime.getTime() - 1000);

//等待一秒时间

Thread.sleep(1000);

//如果在十秒以内继续否则退出

if(end -10000 > endTime.getTime()){

System.out.println(“ending”);

break;

}

}

}

public static void test1() throws InterruptedException{

int num = 10;

while(true){

System.out.println(num–);

Thread.sleep(1000);//暂停

if(num <= 0){

break;

}

}

}

}

2)、模拟网络延时

package com.org.status;

/**

• Sleep模拟 网络延时 线程不安全的

• @author lyy

*/

public class SLeepDemo02 {

public static void main(String[] args) {

//真实角色

Web12306 web = new Web12306();

//代理角色

Thread t1 = new Thread(web,“工程师”);

Thread t2 = new Thread(web,“黄牛已”);

Thread t3 = new Thread(web,“路人甲”);

//启动线程

t1.start();

t2.start();

t3.start();

}

}

class Web12306 implements Runnable{

private int num = 80;

@Override

public void run() {

while(true){

if(num <= 0){

break;//跳出循环

}

try {

Thread.sleep(500);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+“抢到了”+num–);

}

}

}

同步:并发多个线程访问同一份资源确保资源安全  ==> 线程安全

Synchronized  --> 同步

一、同步块

Synchronized（引用类型|this|类.class）{

}

package com.org.syn;

public class SynDemo01 {

public static void main(String[] args) {

//真实角色

Web123 web = new Web123();

//代理角色

Thread t1 = new Thread(web,“工程师”);

Thread t2 = new Thread(web,“黄牛已”);

Thread t3 = new Thread(web,“路人甲”);

//启动线程

t1.start();

t2.start();

t3.start();

}

}

class Web123 implements Runnable{

private int num = 10;

private boolean flag = true;

@Override

public void run() {

while(flag){

test3();

}

}

//线程不安全 锁定资源不正确

public void test6(){

//a b c

if(num <= 0){

flag =false;//跳出循环

return;

}

synchronized (this) {

try {

Thread.sleep(500);//模拟 延时

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+“抢到了”+num–);

}

}

//线程不安全 锁定资源不正确

public void test5(){

//a b c

synchronized ((Integer)num) {

if(num <= 0){

flag =false;//跳出循环

return;

}

try {

Thread.sleep(500);//模拟 延时

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+“抢到了”+num–);

}

}

//锁定范围不正确

public void test4(){

//a b c

synchronized (this) {

if(num <= 0){

flag =false;//跳出循环

return;

}

try {

Thread.sleep(500);//模拟 延时

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+“抢到了”+num–);

}

}

//线程安全，锁定正确

public void test3(){

//a b c

synchronized (this) {

if(num <= 0){

flag =false;//跳出循环

return;

}

try {

Thread.sleep(500);//模拟 延时

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+“抢到了”+num–);

}

}

public synchronized void test2(){

if(num <= 0){

flag =false;//跳出循环

return;

}

try {

Thread.sleep(500);//模拟 延时

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+“抢到了”+num–);

}

//线程不安全

public void test1(){

if(num <= 0){

flag =false;//跳出循环

return;

}

try {

Thread.sleep(500);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+“抢到了”+num–);

}

}

二、同步方法

Synchronized

线程安全的效率慢，保证资源的正确

线程不安全的效率快

三、死锁：过多的同步容易造成死锁

package com.org.syn;

/**

• 过多的方法可能造成死锁

• @author lyy

*/

public class SncDemo3 {

public static void main(String[] args) {

Object g = new Object();

Object m = new Object();

Test t1 = new Test(g,m);

Test t2 = new Test(g,m);

Thread proxy1 = new Thread(t1);

Thread proxy2 = new Thread(t2);

proxy1.start();

proxy2.start();

}

}

class Test implements Runnable{

Object goods;

Object money;

public Test(Object goods, Object money) {

this.goods = goods;

this.money = money;

}

@Override

public void run() {

while(true){

test();

}

}

public void test(){

synchronized (goods) {

try {

Thread.sleep(500);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

synchronized (money) {

// System.out.println(“一手给货”);

}

}

}

class test2 implements Runnable{

Object goods;

Object money;

public test2(Object goods, Object money) {

this.goods = goods;

this.money = money;

}

@Override

public void run() {

while(true){

test();

}

}

public void test(){

synchronized (money) {

try {

Thread.sleep(500);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

synchronized (goods) {

System.out.println(“一手给货”);

}

}

}

解决方法：生产者消费者模式

先生产，在消费

package com.org.pro;

/**

• 一个场景,一个共同的资源

• 生产者和消费者模式信号灯法

• wait() 等待 释放锁 sleep 不释放锁

• notify()/notifyAll() 唤醒

• 与 synchronized

• @author lyy

*/

public class Movie {

private String pic;

//信号灯

//flag --> T 生产者生产 消费者消费 生产完成后 通知消费

//flag --> f 消费者消费 生产者等待 消费完成后唤醒生产

private boolean flag = true;

public synchronized void play(String pic){

if(!flag){//生产者等待

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

//开始生产

try {

Thread.sleep(500);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(“生产了：”+pic);

//生产完毕

this.pic = pic;

//通知消费

this.notify();

//生产者停下

this.flag=false;

}

public synchronized void watch(){

if(flag){//消费者等待

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

try {

//开始消费

Thread.sleep(200);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(“消费了：”+pic);

//消费完毕

//通知生产

this.notify();

//消费停止

this.flag = true;

}

}

}

package com.org.pro;

/**

• 生产者

• @author lyy

*/

public class Player implements Runnable{

private Movie m;

public Player(Movie m) {

super();

this.m = m;

}

@Override

public void run() {

for (int i = 0; i < 100; i++) {

if(0 == i%2){

m.play(“左青龙”);

}else{

m.play(“右白虎”);

}

}

}

}

package com.org.pro;

/**

• 消费者

• @author lyy

*/

public class Watcher implements Runnable{

private Movie m;

public Watcher(Movie m) {

super();

this.m = m;

}

@Override

public void run() {

for (int i = 0; i < 100; i++) {

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
**

• 生产者

• @author lyy

*/

public class Player implements Runnable{

private Movie m;

public Player(Movie m) {

super();

this.m = m;

}

@Override

public void run() {

for (int i = 0; i < 100; i++) {

if(0 == i%2){

m.play(“左青龙”);

}else{

m.play(“右白虎”);

}

}

}

}

package com.org.pro;

/**

• 消费者

• @author lyy

*/

public class Watcher implements Runnable{

private Movie m;

public Watcher(Movie m) {

super();

this.m = m;

}

@Override

public void run() {

for (int i = 0; i < 100; i++) {

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-opQ5hNOJ-1715704727531)]

[外链图片转存中…(img-wf3V6BXQ-1715704727531)]

[外链图片转存中…(img-tkjYTk70-1715704727531)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！