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

1. 继承Thread类，并重写run方法。

2. 实现Runnable接口，重写run方法

3. 实现Callable<返回值>接口，重写call方法

实例如下

继承Thread

---

class test extends Thread{

@Override

public void run() {

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

}

}

开始启动线程：

new test().start()

实现Runnable

---

class God implements Runnable{

@Override

public void run() {

while (true)

{

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

}

}

}

开始启动线程

new Thread(New God()).start

实现Callable

---

class dThread implements Callable {

private String url;

private String name;

public dThread(String url,String name)

{

this.url=url;

this.name= name;

}

@Override

public Boolean call() {

Download d = new Download();

System.out.println(Thread.currentThread().getName()+“开始下载”);

d.imageDownload(url,name);

return Thread.currentThread().isAlive();

}

}

开始启动线程

FutureTask threadTask= new FutureTask<>(new dThread());

new Thread(threadTask).start

开始执行线程只需在线程对象调用start或call方法便开始执行线程

#####################################################

线程池的使用：

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

我们需要使用ExecutorService对象里面

一个方法newFixedThreadPool(5);，参数为线程存放个数。

实例对象调用execute方法，参数为runable对象

使用案例如下

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)