标签：创建线程 thread 3.4 自己 state 结构 联系 传递 重写
我们先定义一个线程类，代码如下：
1 package com.buwei; 2 3 /** 4 * @author buwei 5 * @date 2018/12/24 20:07 6 */ 7 public class MyThread extends Thread { 8 /** 9 * 利用继承中的特点 10 * 将线程名称传递,进行设置 11 * 12 * @param name 线程的名称 13 */ 14 public MyThread(String name) { 15 super(name); 16 } 17 18 /** 19 * 重写run方法 20 * 定义线程要执行的代码 21 */ 22 @Override 23 public void run() { 24 for (int i = 0; i < 20; i++) { 25 // getName（）方法来自父亲 26 System.out.println(getName() + i); 27 } 28 } 29 }
再定义一个测试类，如下：
1 package com.buwei; 2 3 /** 4 * @author buwei 5 * @date 2018/12/24 20:15 6 */ 7 public class MyThreadTest { 8 public static void main(String[] args) { 9 MyThread mt = new MyThread("小强"); 10 // 开启新的线程 11 mt.start(); 12 for (int i = 0; i < 20; i++) { 13 System.out.println("旺财" + i); 14 } 15 } 16 }
执行流程图如下：
程序启动时运行main时候，Java虚拟机启动一个进程，主线程main在main()调用的时候被创建，随着调用mt对象的start方法，另外一个新的线程也启动了，这样，这个应用就在多线程下运行。要想让效果看起来更明显一些，我们可以让打印的次数更多一些来执行。
多线程在执行时，在栈内存中，每一个执行线程都有一片自己所属的栈内存空间，进行方法的压栈和弹栈。
当执行线程的任务结束了，线程自动在栈内存中释放了，但是当所有的执行线程都结束了，那么进程就结束了。
构造方法：
常用方法：
我们在查询API后可以得知创建线程的方式总共有两种，一种是继承Thread类方法，一种是时间Runable接口方式，前面的我们展示的是第一种，现在我们讲解第二种
采用Java.lang.Runnable也是非常常见的方法之一，我们只需要重写run方法即可
步骤如下：
代码如下：
1 package com.buwei; 2 3 /** 4 * @author buwei 5 * @date 2018/12/24 20:53 6 */ 7 public class MyRunnable implements Runnable{ 8 @Override 9 public void run() { 10 for (int i = 0; i < 20; i++) { 11 System.out.println(Thread.currentThread().getName()+i); 12 } 13 } 14 }
1 package com.buwei; 2 3 /** 4 * @author buwei 5 * @date 2018/12/24 20:55 6 */ 7 public class MyRunnableTest { 8 public static void main(String[] args) { 9 // 创建自定义类对象，线程任务对象 10 MyRunnable mr = new MyRunnable(); 11 // 创建线程对象 12 Thread t = new Thread(mr, "小强"); 13 t.start(); 14 for (int i = 0; i < 20; i++) { 15 System.out.println("旺财" + i); 16 } 17 } 18 }
通过实现Runnable接口，使得该类有了多线程类的特性。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法中，Thread类实际上也是实现了Runnable接口的类。
在启动多线程的时候，需要先通过Thread类的构造方法Thread(Runnable targer)构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
实际上所有的所线程代码都是通过Thread的start()方法来运行的，因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。
tips：Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run方法仅作为线程执行体。而时间的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。
如果一个类继承Thread，则不适合资源共享，但是如果实现了Runnable接口的话，则很容易的实现资源共享。
总结：实现Runnable接口比继承Thread类所具有的优势：
补充：在Java中，每次程序的运行至少启动两个线程。一个是main线程，一个是垃圾收集线程。因为每当使用Java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实就是在操作系统中启动了一个进程
使用线程的匿名内部类的方式，可以方便的实现每个线程执行不同的线程操作。
使用匿名内部类的方式实现Runable接口，重写Runnable接口中的run()方法：
1 package com.buwei; 2 3 /** 4 * @author buwei 5 * @date 2018/12/24 21:15 6 */ 7 public class NoNameInnerClassThread { 8 public static void main(String[] args) { 9 Runnable r = new Runnable() { 10 @Override 11 public void run() { 12 for (int i = 0; i < 20; i++) { 13 System.out.println("小强" + i); 14 } 15 } 16 }; 17 new Thread(r).start(); 18 for (int i = 0; i < 20; i++) { 19 System.out.println("旺财" + i); 20 } 21 } 22 }
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行的结构单线程一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
我们用一个生活中常见的电影院卖票的案例来演示线程的安全问题：
我们模拟电影院现在要播放一场电影，《楚门的世界》，本次电影总共是有100个座位，三个窗口同时开启卖票。
用线程对象来模拟窗口，票的张数来模拟Runnable接口的子类
1 package com.buwei; 2 3 /** 4 * @author buwei 5 * @date 2018/12/24 21:24 6 */ 7 public class Ticket implements Runnable { 8 private int ticket = 100; 9 @Override 10 public void run() { 11 // 每个窗口都可以执行卖票，窗口全部开启 12 while (true){ 13 // 有票可以卖 14 if (ticket > 0){ 15 try { 16 // sleep模拟出票时间 17 Thread.sleep(100); 18 } catch (InterruptedException e) { 19 e.printStackTrace(); 20 } 21 // 获取当前线程对象的名字 22 String name = Thread.currentThread().getName(); 23 System.out.println(name + "正在卖第" + ticket-- + "张票"); 24 } 25 } 26 } 27 }
1 package com.buwei; 2 3 /** 4 * @author buwei 5 * @date 2018/12/24 21:29 6 */ 7 public class TicketTest { 8 public static void main(String[] args) { 9 // 创建线程任务对象 10 Ticket ticket = new Ticket(); 11 // 创建撒个窗口对象 12 Thread thread1 = new Thread(ticket, "窗口1"); 13 Thread thread2 = new Thread(ticket, "窗口2"); 14 Thread thread3 = new Thread(ticket, "窗口3"); 15 16 //三个窗口同时卖票 17 thread1.start(); 18 thread2.start(); 19 thread3.start(); 20 } 21 }
这时候就会出现问题：
后面的票提前卖，票被超卖，以及票被重复卖等等问题。
这种问题，就是因为几个窗口的票数不同步了，我们称之为线程不安全
线程安全问题都是由全局变量和静态变量引起的，如果每个线程对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量时线程安全的，但是如果有多个线程同时执行写操作，我们就要考虑线程安全的问题了。
Java中对于多线程的问题提供了同步机制（synchronized）来解决这个问题。
有三种方式可以完成同步操作：
1 synchronized（同步锁）{ 2 需要同步操作的代码 3 }
1 package com.buwei; 2 3 /** 4 * @author buwei 5 * @date 2018/12/24 21:24 6 */ 7 public class Ticket implements Runnable { 8 private int ticket = 100; 9 10 @Override 11 public void run() { 12 // 每个窗口都可以执行卖票，窗口全部开启 13 synchronized (this){ 14 while (true){ 15 // 有票可以卖 16 if (ticket > 0){ 17 try { 18 // sleep模拟出票时间 19 Thread.sleep(100); 20 } catch (InterruptedException e) { 21 e.printStackTrace(); 22 } 23 // 获取当前线程对象的名字 24 String name = Thread.currentThread().getName(); 25 System.out.println(name + "正在卖第" + ticket-- + "张票"); 26 } 27 } 28 } 29 } 30 }
1 public synchronized void method(){ 2 可能会产生线程安全问题的代码 3 }
1 package com.buwei; 2 3 /** 4 * @author buwei 5 * @date 2018/12/24 21:24 6 */ 7 public class Ticket implements Runnable { 8 private int ticket = 100; 9 10 @Override 11 public void run() { 12 // 每个窗口都可以执行卖票，窗口全部开启 13 while (true) { 14 sellTicket(); 15 } 16 } 17 18 public synchronized void sellTicket(){ 19 // 有票可以卖 20 if (ticket > 0){ 21 try { 22 // sleep模拟出票时间 23 Thread.sleep(100); 24 } catch (InterruptedException e) { 25 e.printStackTrace(); 26 } 27 // 获取当前线程对象的名字 28 String name = Thread.currentThread().getName(); 29 System.out.println(name + "正在卖第" + ticket-- + "张票"); 30 } 31 } 32 }
Lock锁：java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象
1 package com.buwei; 2 3 import java.util.concurrent.locks.Lock; 4 import java.util.concurrent.locks.ReentrantLock; 5 6 /** 7 * @author buwei 8 * @date 2018/12/24 21:24 9 */ 10 public class Ticket implements Runnable { 11 private int ticket = 100; 12 13 Lock lock = new ReentrantLock(); 14 15 @Override 16 public void run() { 17 // 每个窗口都可以执行卖票，窗口全部开启 18 while (true) { 19 lock.lock(); 20 // 有票可以卖 21 if (ticket > 0) { 22 try { 23 // sleep模拟出票时间 24 Thread.sleep(100); 25 } catch (InterruptedException e) { 26 e.printStackTrace(); 27 } 28 // 获取当前线程对象的名字 29 String name = Thread.currentThread().getName(); 30 System.out.println(name + "正在卖第" + ticket-- + "张票"); 31 } 32 lock.unlock(); 33 } 34 } 35 }
当线程被创建并启动以后，它即不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，在线程的生命周期中，在Java.lang.Thread.State枚举类中给了六种线程状态：
描述：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。
在我们在的run方法方法中添加sleep语句就是所谓的TimedWaiting计时等待
sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始like执行
Timed Waiting线程状态图
描述：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。
比如：线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，name线程B就进入到Blocked锁阻塞状态。
这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态，Blocked线程状态图如下：
描述：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。
Waiting线程状态图：
tips：我们在翻阅API的时候会发现Timed Waiting（计时等待） 与 Waiting（无限等待） 状态联系还是很紧密的，比如Waiting（无限等待） 状态中wait方法是空参的，而timed waiting（计时等待） 中wait方法是带参的。这种带参的方法，其实是一种倒计时操作，相当于我们生活中的小闹钟，我们设定好时间，到时通知，可是如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了，那么这种设计方案其实是一举两得。如果没有得到（唤醒）通知，那么线程就处于Timed Waiting状态,直到倒计时完毕自动醒来；如果在倒计时期间得到（唤醒）通知，那么线程从Timed Waiting状态立刻唤醒。
下表来自：https://blog.csdn.net/u012403290/article/details/64910926
标签：创建线程 thread 3.4 自己 state 结构 联系 传递 重写
原文地址：https://www.cnblogs.com/buwei/p/10171383.html
