java多线程使用详解与案例，超详细 |
您所在的位置：网站首页 › monitorout接口最简单三个步骤 › java多线程使用详解与案例，超详细 |
|
文章目录
线程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 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{ @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 //第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 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 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 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 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(); } } } } |
今日新闻 |
点击排行 |
|
推荐新闻 |
图片新闻 |
|
专题文章 |
| CopyRight 2018-2019 实验室设备网 版权所有 win10的实时保护怎么永久关闭 |