线程入门

1.创建线程的三种方式

1.1 继承Thread类,重写run()

  1. public class ExtendThread extends Thread {  //继承Thread类
  3.     @Override
  4.     public void run() {                        //重写run()方法, run()方法中包含线程的执行体
  5.         for (int i = 0; i < 1000; i++) {
  6.             System.out.println("画圆");
  7.         }
  8.     }
  11.     public static void main(String[] args) {
  12.         //创建实例,start()使线程进入就绪状态
  13.         ExtendThread extendThread = new ExtendThread();
  14.         extendThread.start();
  16.         //main线程，用于与创建的线程对比
  17.         for (int i = 0; i < 1000; i++) {
  18.             System.out.println("画方");
  19.         }
  20.     }
  21. }

1.2 实现Runnable接口,重写run()

  1. public class ImplementsRunnable implements Runnable {
  2.     //重写run(), run()方法中包含线程的执行体
  3.     @Override
  4.     public void run() {
  5.         //Thread.sleep()使线程休眠,模拟延时
  6.         try {
  7.             Thread.sleep(500);
  8.         } catch (InterruptedException e) {
  9.             e.printStackTrace();
  10.         }
  11.         for (int i = 0; i < 20; i++) {
  12.             System.out.println("画圆");
  13.         }
  14.     }
  16.     public static void main(String[] args) {
  17.         //创建实现接口的实例
  18.         ImplementsRunnable implementsRunnable = new ImplementsRunnable();
  20.         //创建线程的语法     
  21.         //Thread thread = new Thread(runnable);
  22.         //start()使线程进入就绪状态
  23.         //thread.start();
  24.         //简化为下
  25.         new Thread((implementsRunnable)).start();
  27.          //main线程，用于与创建的线程对比
  28.         for (int i = 0; i < 20; i++) {
  29.             System.out.println("画方块");
  30.         }
  31.     }
  32. }

应用: 龟兔赛跑

  1. //龟兔赛跑
  2. public class Race implements Runnable {
  3.     static String Winner = null;
  5.     @Override
  6.     public void run() {
  7.         for (int i = 0; i <= 100; i++) {
  8.             System.out.println(Thread.currentThread().getName() + " 跑了 " + i + " 步");
  10.             //跑到终点,产生胜者,结束循环
  11.             if (gameOver(i)) {
  12.                 Winner = Thread.currentThread().getName();
  13.                 System.out.println(Winner+" 赢了");
  14.                 break;
  15.             }
  16.             //已存在胜者,结束循环
  17.             if (Winner != null) {
  18.                 break;
  19.             }
  20.         }
  21.     }
  23.     private boolean gameOver(int step) {
  24.         if (step >= 100) {
  25.             return true;
  26.         } else {
  27.             return false;
  28.         }
  29.     }
  31.     public static void main(String[] args) {
  32.         Race race = new Race();
  34.         new Thread(race,"兔子").start();
  35.         new Thread(race,"乌龟").start();
  36.     }
  37. }

1.3 实现Callable接口,重写call()

  1. public class ImplementsCallable implements Callable<Integer> { //Callable后加上泛型
  2.     //该 call() 方法将作为线程执行体，并且有返回值。
  3.     @Override
  4.     public Integer call() throws Exception {
  5.         int i;
  6.         for (i = 0; i < 10; i++) {
  7.             System.out.println(Thread.currentThread().getName()+" "+i);
  8.         }
  9.         return i;
  10.     }
  12.     public static void main(String[] args) {
  13.         //创建 Callable接口实现类的实例
  14.         ImplementsCallable ctt = new ImplementsCallable();
  15.         //使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值
  16.         //类似C++中容器
  17.         FutureTask<Integer> ft = new FutureTask<>(ctt);
  19.         for (int i = 0; i < 100; i++) {
  20.             System.out.println(Thread.currentThread().getName() + " 的循环变量i的值" + i);
  21.             if (i == 20) {
  22.                 //使用 FutureTask类的对象作为 Thread 对象的 target 创建并启动新线程
  23.                 new Thread(ft, "有返回值的线程").start();
  24.             }
  25.         }
  26.         //调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值
  27.         try {
  28.             System.out.println("子线程的返回值：" + ft.get());
  29.         } catch (Exception e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  33. }

2.操作线程

sleep()

  1. Thread.sleep(millis);

用sleep()模拟网络延时，放大问题的发生可能性

每个对象都有一把锁，sleep()不会释放锁,类似于抱着锁睡觉

  1. //应用: 模拟倒计时
  2. public class CountDown {
  3.     public static void main(String[] args) {
  4.         count(10);
  6.     }
  8.     static void count(int time) {
  9.         for (; time >= 0; time--) {
  10.             try {
  11.                 Thread.sleep(1000);  // 模拟延时, 1000ms
  12.             } catch (InterruptedException e) {
  13.                 e.printStackTrace();
  14.             }
  15.             System.out.println(time + " second left...");
  16.         }
  17.     }
  18. }

stop()

在Runnable的实现类中定义标志位, 并定义一个用于转换标志位停止线程的stop()方法, 在线程体run()中通过判断标志位状态来控制线程

  1. public class ThreadStop implements Runnable {
  3.     //定义标志位
  4.     boolean flag = true;
  6.     //线程体
  7.     @Override
  8.     public void run() {
  9.         //线程体使用标志位控制
  10.         while (flag) {
  11.             //循环输出，直至主线程中for循环到第80次
  12.             System.out.println("Thread is running...");
  13.         }
  14.     }
  16.     //定义一个公开的stop()方法，用于转换标志位，停止线程
  17.     public void stop() {
  18.         this.flag = false;
  19.         System.out.println("分线程停止了");
  20.     }
  22.     public static void main(String[] args) {
  24.         ThreadStop runnable = new ThreadStop();
  25.         Thread thread = new Thread(runnable);
  26.         thread.start();
  28.         //主线程
  29.         for (int i = 0; i < 100; i++) {
  30.             System.out.println("main is running..." +i);
  31.             if (i == 80) {
  32.                 //stop方法，转换标志位
  33.                 runnable.stop();
  34.             }
  35.         }
  36.     }
  37. }

getState()

线程的六种基本状态:

新建状态（New） 即用new关键字新建一个线程，这个线程就处于新建状态。

就绪状态（Runnable） 操作系统中的就绪和运行两种状态，在Java中统称为RUNNABLE。

等待状态(WAITING) 进入该状态表示当前线程需要等待其他线程做出一些的特定的动作（通知或中断）。

超时等待状态(TIMED_WAITING) 区别于WAITING，它可以在指定的时间自行返回。

阻塞状态（Blocked） 阻塞状态表示线程正等待监视器锁，而陷入的状态。

消亡状态（Dead） 即线程的终止，表示线程已经执行完毕。

使用getState()方法能够获得线程当前所处的状态

  1. public class ThreadState {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         //使用lambda表达式，创建Thread实例，重写run()方法
  4.         Thread thread = new Thread(() -> {
  5.             for (int i = 0; i < 50; i++) {
  6.                 if (i % 5 == 0) {
  7.                     try {
  8.                         Thread.sleep(100);  //3.TIMED_WAITING
  9.                     } catch (InterruptedException e) {
  10.                         e.printStackTrace();
  11.                     }
  12.                 }
  13.             }
  14.             System.out.println("---------------------");
  15.             //4.TERMINATED
  16.         });
  18.         System.out.println("thread.getState() = " + thread.getState()); //1.NEW
  20.         thread.start(); //2.RUNNABLE
  21.         while (thread.getState() != Thread.State.TERMINATED) {
  22.             System.out.println("thread.getState() = " + thread.getState());
  24.             Thread.sleep(100);
  25.         }
  26.     }
  27. }

setPriority()

使用setPriority()方法来设置线程的优先级

setPriority()方法的参数为可以为Thread的枚举类型属性, 或是1~10的整数, 数字越大优先级越高

  1. public class ThreadPriority {
  2.     public static void main(String[] args) {
  3.         //主线程默认优先级
  4.         System.out.println(Thread.currentThread().getName()+" --> "+ Thread.currentThread().getPriority());
  6.         MyPriority myPriority = new MyPriority();
  8.         Thread t1 = new Thread(myPriority, "t1");
  9.         Thread t2 = new Thread(myPriority, "t2");
  10.         Thread t3 = new Thread(myPriority, "t3");
  11.         Thread t4 = new Thread(myPriority, "t4");
  13.         //先设置优先级再启动
  14.         t1.start();
  16.         t2.setPriority(1);
  17.         t2.start();
  19.         t3.setPriority(4);
  20.         t3.start();
  22.         t4.setPriority(Thread.MAX_PRIORITY);
  23.         t4.start();
  24.     }
  25. }
  27. class MyPriority implements Runnable {
  29.     @Override
  30.     public void run() {
  31.         //执行体打印当前线程名和优先级
  32.         System.out.println(Thread.currentThread().getName()+" --> "+ Thread.currentThread().getPriority());
  33.     }
  34. }

join()

join()调用合并线程，其他线程阻塞, 待调用join的线程执行完毕后，再执行其他线程，类似插队

  1. public class ThreadJoin implements Runnable {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         ThreadJoin threadJoin = new ThreadJoin();
  4.         Thread thread = new Thread(threadJoin, "分线程");
  5.         thread.start();
  7.         for (int i = 0; i < 200; i++) {
  8.             //main线程的i=100时，分线程插入，main线程阻塞
  9.             if (i == 100) thread.join();
  10.             //分线程完全结束后，main线程继续执行
  11.             System.out.println("main is running..." + i);
  12.         }
  13.     }
  15.     @Override
  16.     public void run() {
  17.         for (int i = 0; i < 50; i++) {
  18.             System.out.println(Thread.currentThread().getName() + " is running..." + i);
  19.         }
  20.     }
  21. }

yield()

yield()使得线程礼让，让运行状态的线程重新进入就绪状态, 等待CPU的调度

  1. public class ThreadYield {
  2.     public static void main(String[] args) {
  3.         MyYield myYield = new MyYield();
  5.         new Thread(myYield,"Apple").start();
  6.         new Thread(myYield,"Google").start();
  7.     }
  8. }
  10. class MyYield implements Runnable {
  12.     @Override
  13.     //首次运行时从头开始执行run()
  14.     public void run() {
  15.         System.out.println(Thread.currentThread().getName()+"线程开始执行。。。");
  17.         //线程礼让, 暂停线程, 重新进入就绪状态等待调度
  18.         Thread.yield();
  20.         //礼让后继续执行yield()语句后的代码
  21.         System.out.println(Thread.currentThread().getName()+"线程停止执行。。。");
  22.     }
  23. }

setDaemon()

线程分为用户线程(如main…)和守护线程(如垃圾回收机制gc…)

虚拟机不必等待守护线程结束才结束进程

  1. public class ThreadDaemon {
  2.     public static void main(String[] args) {
  3.         God god = new God();
  4.         People people = new People();
  6.         Thread thread_god = new Thread(god);
  7.         thread_god.setDaemon(true);//通过setDaemon()方法将thread_god线程设为守护线程
  9.         Thread thread_people = new Thread(people);
  11.         thread_god.start();
  12.         thread_people.start();
  14.     }
  15. }
  17. class God implements Runnable {
  18.     @Override
  19.     public void run() {
  20.         //发现死循环并不会一直执行,到用户线程结束即结束
  21.         while (true) {
  22.             try {
  23.                 Thread.sleep(100);
  24.             } catch (InterruptedException e) {
  25.                 e.printStackTrace();
  26.             }
  27.             System.out.println("god bless you!");
  28.         }
  29.     }
  30. }
  32. class People implements Runnable {
  33.     @Override
  34.     public void run() {
  35.         for (int i = 0; i < 100; i++) {
  36.             try {
  37.                 Thread.sleep(100);
  38.             } catch (InterruptedException e) {
  39.                 e.printStackTrace();
  40.             }
  41.             System.out.println("I am happy!");
  42.         }
  43.         System.out.println("Goodbye World!");
  44.     }
  45. }

3.线程池

创建线程池使用Executors.newFixedThreadPool(nThread) 静态工厂方法,参数为池子大小

  1. public class ThreadPool {
  2.     public static void main(String[] args) {
  3.         //1.创建服务,创建线程池
  4.         //  Executors.newFixedThreadPool() 静态工厂方法,参数为池子大小
  5.         ExecutorService service = Executors.newFixedThreadPool(10);
  7.         //2.将线程放入线程池
  8.         service.execute(new MyRunnable());
  9.         service.execute(new MyRunnable());
  10.         service.execute(new MyRunnable());
  11.         service.execute(new MyRunnable());
  13.         //3.关闭线程池
  14.         service.shutdown();
  15.     }
  16. }
  18. class MyRunnable implements Runnable {
  19.     @Override
  20.     public void run() {
  21.         System.out.println(Thread.currentThread().getName() + " is running...");
  22.     }
  23. }

4.锁

在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。

当多线程同时操作同一个对象, 会导致数据紊乱, 线程不安全, 故引入锁

为了解决这些问题, 引入了Synchronized和ReentrantLock两种方式

Synchronized

语法为: synchronized (需要上锁的对象) { 代码块 }

  1. public class BuyTicket implements Runnable {
  3.     //票数
  4.     private Integer ticketNum = 20;
  6.     @Override
  7.     public void run() {
  8.         //循环抢票
  9.         while (true) {
  10.             //引入锁
  11.             //使用synchronized锁上ticketNum,使得多个线程不能同时对ticketNum进行操作
  12.             //执行完一次代码块中的内容就释放锁
  13.             synchronized (ticketNum) {
  14.                 if (ticketNum <= 0) {
  15.                     break;
  16.                 }
  17.                 System.out.println(Thread.currentThread().getName() + "拿到了第" + (ticketNum--) + "张票");
  18.             }
  19.         }
  20.     }
  22.     public static void main(String[] args) {
  23.         //创建Runnable对象
  24.         BuyTicket buyTicket = new BuyTicket();
  26.         //三个线程操作一个Runnable对象
  27.         new Thread(buyTicket, "小红").start();
  28.         new Thread(buyTicket, "小黄").start();
  29.         new Thread(buyTicket, "小蓝").start();
  30.     }
  31. }

ReentrantLock

  1. public class LockDemo {
  2.     public static void main(String[] args) {
  3.         //创建Runnable对象
  4.         Ticket ticket = new Ticket();
  6.         //三个线程操作一个Runnable对象
  7.         new Thread(ticket, "小红").start();
  8.         new Thread(ticket, "小黄").start();
  9.         new Thread(ticket, "小蓝").start();
  10.     }
  11. }
  13. class Ticket implements Runnable {
  14.     private int number = 1000;
  16.     //定义ReentrantLock类的Lock锁
  17.     private ReentrantLock lock = new ReentrantLock();
  19.     @Override
  20.     public void run() {
  22.         while (true) {
  23.             try {
  24.                 //lock()加锁
  25.                 lock.lock();
  27.                 //加锁后判断,不能让多个线程同时判断
  28.                 if (number <= 0) {
  29.                     System.out.println(Thread.currentThread().getName() + "--> 没票了");
  30.                     break;
  31.                 }
  32.                 System.out.println(Thread.currentThread().getName() + " 拿到了 " + (number--) + " 号票");
  34.                 //unlock()解锁
  35.                 lock.unlock();
  36.             } catch (Exception e) {
  37.                 e.printStackTrace();
  38.             }
  39.         }
  40.     }
  41. }

5.死锁

多个线程互相持有对方所需要的资源,相互等待,形成僵持

  1. public class DeadLock {
  2.     public static void main(String[] args) {
  3.         Thread lea = new Thread(new Girl("Lea", 1));
  4.         Thread anna = new Thread(new Girl("Anna", 0));
  6.         lea.start();
  7.         anna.start();
  8.     }
  9. }
  10. //镜子类
  11. class Mirror {
  12. }
  13. //口红类
  14. class LipStick {
  15. }
  17. class Girl implements Runnable {
  18.     private String name;
  19.     private int choice;
  21.     //mirror,lipStick设为static,表示只有一个镜子和口红
  22.     static Mirror mirror = new Mirror();
  23.     static LipStick lipStick = new LipStick();
  25.     //构造器  choice=0或1
  26.     public Girl(String name, int choice) {
  27.         this.name = name;
  28.         this.choice = choice;
  29.     }
  31.     @Override
  32.     public void run() {
  33.         makeup();
  34.     }
  36.     void makeup() {
  37.         //choice为0,先获得镜子的锁,再等待拿口红的锁
  38.         if (choice == 0) {
  39.             synchronized (mirror) {//获得镜子锁
  40.                 System.out.println(this.name + " 获得了镜子的锁");
  41.                 try {
  42.                     Thread.sleep(100);//模拟延时,保证另一个人拿到了另一件物品的锁
  43.                 } catch (InterruptedException e) {
  44.                     e.printStackTrace();
  45.                 }
  46.                 //锁中拿锁,造成死锁
  47.                 synchronized (lipStick) {//获得口红锁
  48.                     System.out.println(this.name + " 获得了口红的锁");
  49.                 }
  50.             }
  51.         } else {
  52.             synchronized (lipStick) {//获得口红锁
  53.                 System.out.println(this.name + " 获得了口红的锁");
  54.                 try {
  55.                     Thread.sleep(200);//模拟延时,保证另一个人拿到了另一件物品的锁
  56.                 } catch (InterruptedException e) {
  57.                     e.printStackTrace();
  58.                 }
  59.                 //锁中拿锁,造成死锁
  60.                 synchronized (mirror) {//获得镜子锁
  61.                     System.out.println(this.name + " 获得了镜子的锁");
  62.                 }
  63.             }
  64.         }
  65.     }
  66. }