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

    @Test
    public void testNoStatic() {
        // 重用非静态方法中的代码【使用方法引用】
        RunnableThreadTest temp = new RunnableThreadTest();
        new Thread(temp::threadRunCode, "线程1").start();
    }


    @Test
    public void testStatic() {
        // 重用静态方法中的代码【使用方法引用】
    new Thread(RunnableThreadTest::threadRunCode_Static, "线程1").start();
             
    }
    @Test
    public 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

image

• FutureTask的构造器

image

• 此时可理解为：FutureTask的作用就是接收一个实现了Callable接口的实现类对象

• 此时注意到FutureTask实现了Runnable接口

  • 也就是说可以把FutureTask的实现类对象传入到Runnable类型

• 而Thread类中的构造器的参数为Runnable类型

• 因此梳理后可知

  ①先实现Callable接口

    class myThread_3 implements Callable{
        @Override
        public String call() throws Exception {
            return "线程创建成功";
        }
    }
  

  ②将Callable实现类对象传给FutureTask构造器

    FutureTask ft = new FutureTask<>(new myThread_3());
  
    * 因为FutureTask实现了Runnable接口，因此以下代码也正确
  
        Runnable runner = new FutureTask(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 ft = new FutureTask(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{
    
        @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 Thread
           Thread 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;
          
          @Override
          public 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不需要设置为共享，因为均为同一对象
    
    @Override
    public 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];
        }
        
        @Override
        public 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++;
        }

        @Override
        public Object delete() throws Exception {
            // TODO Auto-generated method stub
            if(this.isEmpty()) {
                
                throw new Exception("队列为空队");
            }
            
            Object obj=this.queue[front];
            front=(front+1)%maxSize;
            count--;
            
            return obj;
            
        }

        @Override
        public Object getFront() throws Exception {
            // TODO Auto-generated method stub
            if(!this.isEmpty()) {
                
                return this.queue[front];
            }
            return null;
        }

        @Override
        public boolean isEmpty() {
            // TODO Auto-generated method stub
            return 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.count0) {
            Object obj=this.queue.delete();  //出队
            int temp=Integer.parseInt(obj.toString());
            System.out.println("第"+(temp+1)+"个客户买到票离开队列");
            
            //如果当前的队列为空 并且卖出票数大于100
            if(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;
    }
    
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(queue.num<100) {  //必须小于100张票 才可以买票
        try {
            Thread.sleep(1000);
            queue.producer();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }
    }

}

Class Consumer

public class Consumer implements Runnable{
    
    WindowQueue queue;
    
    public Consumer(WindowQueue queue) {
        
        this.queue=queue;
    }
    
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(queue.flag) {  //如果队列为空 并且票数大于100 就不会卖票了
            
            try {
                Thread.sleep(1000);
                queue.consumer();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.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"));
        }
    };