文章目录
线程lamda表达式方式启动（简单、常用）java使用多线程的三种方式：继承Thread实现Runnable实现Callable
线程池的使用：守护线程：使用lamda表达式简化java的书写简单化案例如下：多线程综合案例1、**买票案例****2、信号灯法，通过标志为解决**3、买票与卖票。
java多线程使用
线程lamda表达式方式启动（简单、常用）
new Thread(()->{
System.out.println("开始了一个线程"+new Date());
}).start();
java使用多线程的三种方式：
继承Thread类，并重写run方法。实现Runnable接口，重写run方法实现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
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{
@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();
}
}
}
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();
}
}
}
}