线程lamda表达式方式启动（简单、常用）

new Thread(()->{System.out.println("开始了一个线程"+new Date());}).start();

java使用多线程的三种方式：

继承Thread类，并重写run方法。
实现Runnable接口，重写run方法
实现Callable<返回值>接口，重写call方法

实例如下

继承Thread

class test extends Thread{@Overridepublic void run() {System.out.println("你好啊");}
}

开始启动线程：

new test().start()

实现Runnable

class God implements Runnable{@Overridepublic void run() {while (true){System.out.println("上帝守护着你");}}
}

开始启动线程

new Thread(New God()).start

实现Callable

class dThread implements Callable<Boolean> {private String url;private String name;public dThread(String url,String name){this.url=url;this.name= name;}@Overridepublic Boolean call() {Download d = new Download();System.out.println(Thread.currentThread().getName()+"开始下载");d.imageDownload(url,name);return Thread.currentThread().isAlive();}
}

开始启动线程

FutureTask <String>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的线程池//固定线程池ExecutorService e = Executors.newFixedThreadPool(5);//单线程池Executors.newSingleThreadExecutor();//可缓存线程池Executors.newCachedThreadPool();//时间周期线程池Executors.newScheduledThreadPool(6);//工作窃取线程池Executors.newWorkStealingPool(2);      //可以指定并行数//调用execute方法开启线程e.execute(new MyThread());//execute:实行e.execute(new test());e.execute(new MyThread());e.execute(new MyThread());e.shutdown();                   //关闭线程}
}
class MyThread implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName());}
}class test extends Thread{@Overridepublic 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{@Overridepublic void run() {while (true){System.out.println("上帝守护着你");}}
}
class HandsomeYou implements Runnable{@Overridepublic 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{@Overridepublic 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{@Overridepublic void lamda() {System.out.println("i'm lamda3");}}s=new son3();s.lamda();//第3步简化->匿名内部类s=new Like() {@Overridepublic void lamda() {System.out.println("i'm Lamda4");}};s.lamda();//第4步简化->Lamdas= ()-> {System.out.println("i'm Lamda5");};s.lamda();}
}
//接口类
interface Like{void lamda();
}
//正常实现类
class son1 implements Like{@Overridepublic 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;}//生产@Overridepublic 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;}//消费@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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();}}
}

3、买票与卖票。

使用加锁。保证票的数量在有的情况才可以出售，解决并发问题demo。

package cn.xjt.gaoji;import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;/*** 买票系统会出现不安全* 需要加上锁* 通过ReenTrantlock对象进行加锁，解锁* private final ReentrantLock locks = new ReentrantLock();* @author xujiangtao* @create 2020-08-01-16:59*/
public class TestReentrantLock {public static void main(String[] args) {buyticket person = new buyticket();Thread t = new Thread(person);t.start();t=new Thread(person);t.start();t= new Thread(person);t.start();}}
//一个卖票的类
class buyticket implements Runnable{//Reentrantlock:可重进锁private final ReentrantLock locks = new ReentrantLock();//票数int ticket =10;@Override//重写的方法public void run() {while (true){try {//开启一个锁        开启一个锁最好放在try语句locks.lock();if(ticket>0){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(ticket--);}else{System.out.println("你买的票已经被购完");break;}}finally {//关闭一个锁locks.unlock();}}}
}

java多线程使用详解与案例，超详细相关推荐

java多线程设计模式详解[推荐]
java多线程设计模式详解[推荐] java多线程设计模式详解之一线程的创建和启动 java语言已经内置了多线程支持,所有实现Runnable接口的类都可被启动一个新线程,新线程会执行该实例的run ...
c语言指针用法及实际应用详解，通俗易懂超详细
c语言指针用法及实际应用详解,通俗易懂超详细! \\\插播一条:文章末尾有惊喜哟~/// 今天给大家来讲解一下指针. 我会由浅到深,最后联合实际应用讲解,让大家学会指针的同时,知道大佬们都用指针来干嘛 ...
Java多线程进阶详解
文章目录 1.卖票案例引入数据不安全问题 2.同步代码块深入理解synchronized关键字 3.同步方法与静态同步方法同步方法静态同步方法内置锁静态同步方法与同步代码块共同使用为什么要 ...
Java多线程 - AQS详解
介绍 AQS是java.util.concurrent.locks下类AbstractQueuedSynchronizer的简称,是用于通过Java源码来构建多线程的锁和同步器的一系列框架,用于Ja ...
40个Java多线程问题详解复习
点击上方"朱小厮的博客",选择"设为星标" 后台回复"加群",加入新技术来源:8rr.co/vXmW 1.多线程有什么用? 一个可能在很多 ...
java多线程设计模式详解
Java多线程设计模式线程的创建和启动 Java语言已经内置了多线程支持,所有实现Runnable接口的类都可被启动一个新线程,新线程会执行该实例的run()方法,当run()方法执行完毕后,线程就 ...
java多线程编程从入门到卓越(超详细总结）
导读:java多线程编程不太熟?或是听说过?或是想复习一下?找不到好的文章?别担心我给你们又安利一波,文章内容很全,并且考虑到很多开发中遇到的问题和解决方案.循环渐进,通俗易懂,文章较长,建议收藏再看 ...
Java——多线程使用详解
多线程: 多线程就是同时执行多个应用程序,需要硬件的支持同时执行:不是某个时间段同时,cpu切换的比较快,所有用户会感觉是在同时运行并发与并行: 并行(parallel):指在同一时刻,有多条指令 ...
Java 多线程 —— AQS 详解
引言 AQS 是AbstractQuenedSynchronizer 的缩写,抽象的队列式同步器,它是除了java自带的synchronized关键字之外的锁机制.是 JUC 下的重要组件. 相关产物 ...

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

文章目录