java多线程使用详解与案例，超详细(1)

使用案例如下

package cn.xjt.gaoji;

import java.util.concurrent.Executor;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

• 测试线程池

• @author xujiangtao

• @create 2020-08-02-14:42

*/

public class TestPool { //pool:池子

public static void main(String[] args) {

//创建了一个大小为10的线程池

//executor 执行者 service: 服务 fixed:确定的 pool:池子

ExecutorService e = Executors.newFixedThreadPool(5);

//调用execute方法开启线程

e.execute(new MyThread());

//execute:实行

e.execute(new test());

e.execute(new MyThread());

e.execute(new MyThread());

e.shutdown(); //关闭线程

}

}

class MyThread implements Runnable{

@Override

public void run() {

System.out.println(Thread.currentThread().getName());

}

}

class test extends Thread{

@Override

public void run() {

System.out.println(“你好啊”);

}

}

守护线程：

========================================================================

daemon守护线程会因为用户线程关闭而关闭，默认为用户线程

Thread实例对象setDarmon()方法可以设置是否为守护者线程，默认为false。

守护线程会随着用户线程的结束而结束

java守护线程案例如下：

package cn.xjt.demo03;

/**

• daemon守护线程会因为用户线程关闭而关闭，默认为用户线程

• y

• @author xujiangtao

• @create 2020-08-01-10:36

*/

public class TestDaemon {

public static void main(String[] args) {

God god = new God();

HandsomeYou handsomeyou = new HandsomeYou();

Thread thread = new Thread(god);

thread.setDaemon(true); //上帝守护线程

thread.start();

new Thread(handsomeyou).start();

}

}

class God implements Runnable{

@Override

public void run() {

while (true)

{

System.out.println(“上帝守护着你”);

}

}

}

class HandsomeYou implements Runnable{

@Override

public void run() {

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

System.out.println(“Hello world 你开心的活着”);

}

System.out.println(“goodbye world==”);

}

}

使用lamda表达式简化java的书写简单化案例如下：

==============================================================================================

package cn.xjt.demo03;

/**

• @author xujiangtao

• @create 2020-07-31-20:10

*/

public class TestLamda {

//第1步简化->静态内部类

static class son2 implements Like{

@Override

public void lamda() {

System.out.println(“i’m lamda2”);

}

}

public static void main(String[] args) {

Like s = new son1();

s.lamda();

s=new son2();

s.lamda();

//第2步简化->局部内部类

class son3 implements Like{

@Override

public void lamda() {

System.out.println(“i’m lamda3”);

}

}

s=new son3();

s.lamda();

//第3步简化->匿名内部类

s=new Like() {

@Override

public void lamda() {

System.out.println(“i’m Lamda4”);

}

};

s.lamda();

//第4步简化->Lamda

s= ()-> {

System.out.println(“i’m Lamda5”);

};

s.lamda();

}

}

//接口类

interface Like{

void lamda();

}

//正常实现类

class son1 implements Like{

@Override

public void lamda() {

System.out.println(“i’m lamda”);

}

}

多线程综合案例

==========================================================================

1、买票案例

---

使用生产者消费者模式。通过缓存区，保证产品数量大于消费数量

package cn.xjt.gaoji;

/**

• 测试生产者消费者–>利用缓冲区：管程法

• @author xujiangtao

• @create 2020-08-01-21:53

*/

//成产者，消费者，产品，缓存区

public class TestPC {

public static void main(String[] args) {

Syncontainer syncontainer = new Syncontainer();

new Productor(syncontainer).start();

new Consumer(syncontainer).start();

}

}

//生产者

class Productor extends Thread{

Syncontainer container;

public Productor(Syncontainer container)

{

this.container=container;

}

//生产

@Override

public void run() {

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

try {

container.push(new Chicken(i));

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(“生产了”+(i+1)+“只鸡”);

}

}

}

//消费者

class Consumer extends Thread{

Syncontainer container;

public Consumer(Syncontainer container)

{

this.container=container;

}

//消费

@Override

public void run() {

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

try {

System.out.println(“消费了->”+container.pop().id+“只鸡”);

System.out.println(Thread.currentThread().getName());

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

//产品

class Chicken{

int id;

Chicken(int id)

{

this.id=id;

}

}

//缓冲区

class Syncontainer{

//需要一个容器大小

Chicken[] chickens = new Chicken[10];

int count =0;

//生产者放入产品

public synchronized void push(Chicken chicken) throws InterruptedException {

//如果容器满了，需要消费者消费

if(count ==chickens.length)

{

this.wait();

}

//如果没有满，就需要生产产品放入

chickens[count] = chicken;

count++;

//可以通知消费者了

this.notifyAll();

}

//消费者消费产品

public synchronized Chicken pop() throws InterruptedException {

//判断缓冲区是否还有产品

if(count==0)

{

//等待生产者生产，消费者等待

this.wait();

}

count–;

return chickens[count];

// this.notifyAll();

//吃完了，通知生产者生产

}

}

2、信号灯法，通过标志为解决

---

package cn.xjt.gaoji;

/**

• 测试生产者，消费者问题 2：信号灯法

• 标志位解决

• @author xujiangtao

• @create 2020-08-02-13:11

*/

public class TestPC2 {

public static void main(String[] args) {

TV tv = new TV();

new actor(tv).start();

new watcher(tv).start();

}

}

//生产者->演员

class actor extends Thread{

TV tv;

public actor(TV tv)

{

this.tv=tv;

}

@Override

public void run() {

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

try {

if(i%2==0)

{

tv.play(“抖音:记录美好生活”);

System.out.println(i);

}else{

tv.play(“快乐大本营”);

System.out.println(i);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

//消费者->观众

class watcher extends Thread{

TV tv;

public watcher(TV tv)

{

this.tv=tv;

}

@Override

public void run() {

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

try {

tv.watch(“观众”);

System.out.println(i);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

//产品->Tv

class TV{

String video;

// String Watchername;

boolean flag = true;

//演员表演，观众等待 T

//观众观看，演员等待 F

//表演方法

public synchronized void play(String vidio) throws InterruptedException {

//判断如果是true，则表演节目

if(flag)

{

System.out.println(“演员表演了->”+vidio);

Thread.sleep(1000);

//通知观众观看

this.notifyAll(); //通知观众观看节目

this.video=vidio;

flag=!this.flag;

}else { //否则，等待观众观看

this.wait();

}

}

public synchronized void watch(String watchername) throws InterruptedException {

//判断如果为flase，则观众观看节目

if(!flag)

{

System.out.println(watchername+“观看了”+video);

Thread.sleep(1000);

this.notifyAll();

flag=!flag;

}else{ //否则等待，直到表演者表演完，再继续观看

this.wait();

}

}

}

最后

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

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

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

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

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

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

Thread.sleep(1000);

this.notifyAll();

flag=!flag;

}else{ //否则等待，直到表演者表演完，再继续观看

this.wait();

}

}

}

最后

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

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

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

[外链图片转存中…(img-Fzo4otnP-1715729914960)]

[外链图片转存中…(img-IdFwNIqM-1715729914960)]

[外链图片转存中…(img-IhqioVEl-1715729914961)]

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

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

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