一、创建线程三种方式

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接口不存在泛型

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"));}};