线程(Lambda表达式创建线程)"/>
Java创建线程(Lambda表达式创建线程)
一、创建线程三种方式
1.1 继承Thread类创建线程类(main线程与t线程交替执行)
1.2 通过Runnable接口创建线程类
弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
上述代码中Thread.currentThread()
方法返回当前正在执行的线程对象。GetName()
方法返回调用该方法的线程的名字。
public class RunnableThreadTest implements Runnable {private int i;public void run() {for (i = 0; i < 5; i++) {System.out.println(Thread.currentThread().getName() + " " + i);}}public static void main(String[] args) {for (int i = 0; i < 3; i++) {System.out.println(Thread.currentThread().getName() + " " + i);if (i == 2) {RunnableThreadTest rtt = new RunnableThreadTest();new Thread(rtt, "新线程1").start();new Thread(rtt, "新线程2").start();}}}
}
使用Lambda表达式
public class RunnableThreadTest {// 目的是为了代码的重用【静态方法】public static void threadRunCode_Static() {System.out.println(Thread.currentThread().getName() + " " + }// 目的是为了代码的重用【非静态方法】public void threadRunCode() {System.out.println(Thread.currentThread().getName() + " " + i);}@Testpublic void testNoStatic() {// 重用非静态方法中的代码【使用方法引用】RunnableThreadTest temp = new RunnableThreadTest();new Thread(temp::threadRunCode, "线程1").start();}@Testpublic void testStatic() {// 重用静态方法中的代码【使用方法引用】new Thread(RunnableThreadTest::threadRunCode_Static, "线程1").start();}@Testpublic void testLambda() {// 重用静态方法中的代码【使用方法引用】new Thread(() -> { System.out.println(Thread.currentThread().getName() + " " + b);},"线程1").start();
}
匿名内部类实现线程
1、继承Thread类
new Thread() { //1.继承Thread类public void run(){ //2.重写run方法for(int i = 0;i < 1000;i++) {System.out.println("aaaaaa");}}}.start(); //3.开启线程
2、实现Runnable接口
new Thread(new Runnable() { //1.将Runnable子类对象传递给Thread构造方法public void run(){ //2.重写run方法for(int i = 0;i < 1000;i++) { System.out.println("bb");}} }).start(); //3.开启线程
1.3 线程的第三种创建方式
-
使用Callable接口_java.util.concurrent
image
- Callable接口与Runnable接口的区别:
- Runnable没有返回值一说,而且run()方法并不抛出异常
- Callable中的call方法具有返回值
- Callable之所以有返回值,也是因为实现了泛型,而Runnable接口不存在泛型
- Callable接口与Runnable接口的区别:
7.1 FutureTask类的学习——java.util.concurrent.FutureTask<V>
image
- FutureTask的构造器
image
-
此时可理解为:FutureTask的作用就是接收一个实现了Callable接口的实现类对象
-
此时注意到FutureTask实现了Runnable接口
- 也就是说可以把FutureTask的实现类对象传入到Runnable类型
- 而Thread类中的构造器的参数为Runnable类型
-
因此梳理后可知
①先实现Callable接口
class myThread_3 implements Callable<String>{@Overridepublic String call() throws Exception {return "线程创建成功";}}
②将Callable实现类对象传给FutureTask构造器
FutureTask<String> ft = new FutureTask<>(new myThread_3());* 因为FutureTask实现了Runnable接口,因此以下代码也正确Runnable runner = new FutureTask<String>(new myThread_3());* 接口引用指向实现类对象* 但是此时runner只能访问Runnable中方法,不可以访问FutureTask中的方法
③创建线程并启动
new Thread(ft).start();
④使用FutureTask类中方法
public V get() throws InterruptedException,ExecutionException通过Thread启动线程之后 可以通过FutureTask存在get方法可以取得call()方法中的返回值/*用到Callable有什么用?只是为了返回一个值?执行线程的代码run用什么代替?*//*回答:此时线程启动start()方法调用的是call()方法,将需要执行的代码放到call()方法中,同时call()方法的特点在于有返回值*/
-
程序
public class TestCallable{public static void main(String[] args) {FutureTask<String> ft = new FutureTask<String>(new myThread_3());new Thread(ft).start(); //此时的启动需要调用的是call()方法 String result = null;try {result = ft.get();} catch (InterruptedException | ExecutionException e) {e.printStackTrace();} System.out.println(result); } }class myThread_3 implements Callable<String>{@Override public String call() throws Exception { System.out.println("此时start()方法调用的是call()方法");return "线程创建成功";}}/* 在JDK1.8中输出结果为:* ----------------------------* 此时start()方法调用的是call()方法线程创建成功----------------------------* */
2. 多线程(获取名字和设置名字)(掌握)
Thread.currentThread()
方法返回当前正在执行的线程对象
-
Thread类中的方法使用
- getName()
- setName()
- currentthread()
- sleep
- join
- wait
- yield
- setDaemon
-
获取名字【通过getName()方法获取线程对象的名字】
-
public final String getName();
-
-
设置名字
-
通过构造函数可以传入String类型的名字
public Thread(String name)public Thread(Runnable target,String name)
-
通过setName(String)方法可以设置线程对象的名字
public final void setName(String name);
-
-
程序实现
new Thread("线程一") { //设置线程名字public void run() {设置代码块for(int i = 0;i < 100;i++) {System.out.println(this.getName() + "....aaaa"); //获取线程名字}}}.start();new Thread() {public void run() {this.setName("线程3"); //设置线程名字for(int i = 0;i < 100;i++) {System.out.println(this.getName() + "....哈哈");}}}.start();
3. 多线程(获取当前线程的对象)(掌握) 【线程A与线程B 并发执行,顺序不定】
带参的构造函数public Thread(String name)public Thread(Runnable target,String name)
public static Thread currentThread()Thread.currentthread();——注意返回值是Thread//匿名内部类实现当前线程对象的获取
new Thread() { public void run() {this.setName("线程A");for(int i = 0;i < 1000;i++) {System.out.println( Thread.currentThread().getName() + "....aaaa");}}}.start();匿名构造块作为参数new Thread(new Runnable() {public void run() {for(int i = 0;i < 1000;i++) {System.out.println( Thread.currentThread().getName() + "....bb");}}
},"线程B").start();
}
4. 多线程(休眠线程)(掌握)
-
public static void sleep(long millis) throws InterruptedException
- 抛出InterruptionException
public class TestSleepOfThread {public static void main(String[] args) {Runnable r = ()->{try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Thread A");};new Thread(r).start();System.out.println("main Thread");}}/** 在JDK1.8中输出结果为:* -------------* main ThreadThread A-------------* */
5. 多线程(守护线程)(掌握)
-
setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
-
public final void setDaemon(boolean on)
-
on - if true, marks this thread as a daemon thread
public class TestSetDaemon {public static void main(String[] args) {Thread t1 = new Thread("线程A") {public void run() {for(int i = 0;i < 2;i++) {System.out.println(Thread.currentThread().getName() + "....aaaa");}}};Thread t2 = new Thread(new Runnable() {public void run() {for(int i = 0;i < 50;i++) {System.out.println(Thread.currentThread().getName() + "....bb");}}},"线程B");将t2设置为守护线程t2.setDaemon(true); //将t2设置为守护线程 t1.start();t2.start();}}/** 在JDK1.8中输出结果为:* ------------------------* 线程A....aaaa线程B....bb线程A....aaaa线程B....bb //存在时间缓冲问题线程B....bb线程B....bb线程B....bb线程B....bb线程B....bb线程B....bb* */
-
6. 多线程(加入线程)(掌握)
-
join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
-
t1.join(); 当前线程暂停直到 线程t1执行完毕
-
join(int), 可以等待指定的毫秒之后 当前线程继续
-
public final void join() throws InterruptedException
public class TestJoin {public static void main(String[] args) {Thread t1 = new Thread("线程A") {public void run() {for(int i = 0;i < 100;i++) {System.out.println(getName() + "....aaaaaaa");}}};Runnable r = ()->{for(int i = 0;i < 50;i++) {if(i == 2) {try {t1.join(); 当前线程暂停知道 线程t1执行完毕//t1.join(1000); t1插队执行1秒后,t1和t2线程再抢占CPU交替执行} catch (InterruptedException e) {e.printStackTrace();}} System.out.println(Thread.currentThread().getName() + "....bb");}};t1.start();new Thread(r).start();}}
13. 多线程(礼让线程)(了解)
- yield让出cpu
14. 多线程(设置线程的优先级)(了解)
- setPriority()设置线程的优先级
15. 多线程(同步代码块)(掌握)
- 1.什么情况下需要同步
- 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
- 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
- 2.同步代码块
-
使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
-
锁对象不可以用匿名对象,因为匿名对象不是同一个对象
-
多个同步代码块如果使用相同的锁对象, 那么他们就是同步的
public class TestTickets_2 {public static void main(String[] args) {MyThread_6 myt = new MyThread_6();new Thread(myt,"线程A").start();new Thread(myt,"线程B").start();}}class MyThread_6 implements Runnable{private int ticket = 5;@Overridepublic void run() {while(true) {if(this.ticket > 0) {System.out.println(Thread.currentThread().getName() + "开始卖票 = " + ticket--);}else {System.out.println("票已经卖完");break;}} } }
-
16. 多线程(同步方法)(掌握)
public class TestSynchronized_2 {public static void main(String[] args) {Printer_2 p = new Printer_2();Runnable r = ()->{for(int i = 0;i < 100;i++) {p.print1();}};Thread t2 = new Thread() {public void run() {for(int i = 0;i < 100;i++) {p.print2();}}};new Thread(r).start();t2.start(); }
}class Printer_2{同步代码块public synchronized void print1() {System.out.print("早");System.out.print("上");System.out.print("好");System.out.print("啊");System.out.print("\r\n");}public void print2() {synchronized(this) {System.out.print("河");System.out.print("正");System.out.print("宇");System.out.print("好");System.out.print("帅"); System.out.print("\r\n");} }
}
17. 多线程(线程安全问题)(掌握)
-
多线程并发操作同一数据时, 就有可能出现线程安全问题
-
使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作
/** 铁路售票,一共100张,通过四个窗口卖完 * */public class TestSynchronized_3 {public static void main(String[] args) {new Ticket().start();new Ticket().start();new Ticket().start();} }class Ticket extends Thread{private static int ticket = 100;public void run() {while(true) {//synchronized(this)synchronized(Ticket.class) {if(ticket == 0) {break;}System.out.println(getName() + "这是第" + ticket-- + "号票");}}}}
18. 多线程(火车站卖票的例子用实现Runnable接口)(掌握)
public class TestSynchronized_4 {public static void main(String[] args) {Ticket_2 t = new Ticket_2();new Thread(t,"线程A").start();new Thread(t,"线程B").start();new Thread(t,"线程C").start();new Thread(t,"线程D").start();}
}class Ticket_2 implements Runnable{private int ticket = 100; //此时ticket不需要设置为共享,因为均为同一对象@Overridepublic void run() {while(true) {synchronized(this) {if(ticket == 0) {break;}System.out.println(Thread.currentThread().getName() + " 这是第" + ticket-- + "号票");}}}
}
19. 多线程(死锁)(了解)
public class TestDeadLock {private static Object o1 = new Object();private static Object o2 = new Object();public static void main(String[] args) {new Thread("线程A") {public void run() {while(true) {synchronized(o1) {System.out.println(getName() + "正在使用o1,等待o2");synchronized(o2) {System.out.println(getName() +"等到o2,执行成功");}}} }}.start();new Thread("线程B") {public void run() {while(true) {synchronized(o2) {System.out.println(getName() + "正在使用o2,等待o1");synchronized(o1) {System.out.println(getName() + "等到o1,执行成功");}}} }}.start();}
}
/** 在JDK1.8中输出结果为:* ----------------------线程A正在使用o1,等待o2线程A等到o2,执行成功线程A正在使用o1,等待o2线程B正在使用o2,等待o1-------------------------* */
- 因此:synchronized不要嵌套使用,容易出错
20. 多线程和队列实现买卖票
Queue接口
public interface Queue {public void append(Object obj)throws Exception;public Object delete()throws Exception;public Object getFront()throws Exception; public boolean isEmpty();
}
Class MyQueue
public class MyQueue implements Queue{//1 设置队列的默认长度static final int DEFAULT_SIZE=10; //默认长度为10//2 设置队头int front; //3 设置队尾int rear;//4 定义统计元素的变量int count;//5 队的最大长度int maxSize;Object[] queue; //设置队列//空构造public MyQueue() {this.init(DEFAULT_SIZE); //用户给定长度 默认长度为10}//有参数的构造public MyQueue(int size) {this.init(size); //开辟用户给定的长度}/*** 初始化方法* @param size*/public void init(int size) {//初始化属性this.maxSize=size; //外部传进来的size//空队列front=rear=0;count=0;queue=new Object[size];}@Overridepublic void append(Object obj) throws Exception {// TODO Auto-generated method stub//首先队列是否已满if(count>0&&front==rear) { //判断队列是否已满throw new Exception("队列已满");}this.queue[rear]=obj;rear=(rear+1)%maxSize;count++;}@Overridepublic Object delete() throws Exception {// TODO Auto-generated method stubif(this.isEmpty()) {throw new Exception("队列为空队");}Object obj=this.queue[front];front=(front+1)%maxSize;count--;return obj;}@Overridepublic Object getFront() throws Exception {// TODO Auto-generated method stubif(!this.isEmpty()) {return this.queue[front];}return null;}@Overridepublic boolean isEmpty() {// TODO Auto-generated method stubreturn this.count==0;}}
Class WindowQueue
public class WindowQueue { //卖票的窗口//定义卖票队列int maxSize=10;MyQueue queue=new MyQueue(maxSize);int num=0; //最多卖100张票boolean flag=true ; //判断是否继续卖票//排队买票public synchronized void producer()throws Exception{if(this.queue.count<maxSize) {this.queue.append(num++); //等待买票的数量++System.out.println("第"+num+"个客户排队买票");this.notifyAll(); //唤醒等待的线程}else {System.out.println("队列已满 请等待");this.wait(); }}//卖票public synchronized void consumer()throws Exception{if(this.queue.count>0) {Object obj=this.queue.delete(); //出队int temp=Integer.parseInt(obj.toString());System.out.println("第"+(temp+1)+"个客户买到票离开队列");//如果当前的队列为空 并且卖出票数大于100if(this.queue.isEmpty()&&this.num>=100) {this.flag=false;}this.notifyAll(); //唤醒等待的线程}else {System.out.println("队列已空 请等待");this.wait();}}
}
Class Producer
public class Producer implements Runnable{WindowQueue queue;public Producer(WindowQueue queue) {this.queue=queue;}@Overridepublic void run() {// TODO Auto-generated method stubwhile(queue.num<100) { //必须小于100张票 才可以买票try {Thread.sleep(1000);queue.producer();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}
Class Consumer
public class Consumer implements Runnable{WindowQueue queue;public Consumer(WindowQueue queue) {this.queue=queue;}@Overridepublic void run() {// TODO Auto-generated method stubwhile(queue.flag) { //如果队列为空 并且票数大于100 就不会卖票了try {Thread.sleep(1000);queue.consumer();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}
Class QueueTest
public class QueueTest { public static void main(String[] args) throws Exception { WindowQueue queue=new WindowQueue();Producer p=new Producer(queue);Consumer con=new Consumer(queue);//以上的代码一定要注意 传入的是同一个对象Thread t1=new Thread(p);Thread t2=new Thread(con);t1.start();t2.start();}
}
Lambda表达式
-
Lambda表达式的形式
参数,箭头(→)以及一个表示
-
Lambda适用于接口中一个抽象方法时候使用
-
举例1——函数式接口使用
Runnable runner = ()->{StringBuffer s = new StringBuffer();for(int i= 0;i < 10;i++)System.out.println(s.append("haha"));};
-
举例2——只有一个抽象方法的接口的实现类的使用
Thread t1 = new Thread(()->{StringBuffer s = new StringBuffer();for(int i= 0;i < 10;i++)System.out.println(s.append("haha"));});
-
区别于匿名内部类——需要写出方法声明
new Thread(new Runnable() {public void run() {StringBuffer s = new StringBuffer();for(int i= 0;i < 10;i++)System.out.println(s.append("haha"));} }).start(); Thread t1 = new Thread() {public void run() {StringBuffer s = new StringBuffer();for(int i= 0;i < 10;i++)System.out.println(s.append("haha"));}};
更多推荐
Java创建线程(Lambda表达式创建线程)
发布评论