多线程JUC（一）

---

前言

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程的实际运作单位。简单理解：应用软件中互相独立，可以同时运行的功能。

进程是程序执行的基本执行实体。如下图，每一个运行的程序都对应着一个进程。

为什么要有多线程？

如下图所示，当JVM在内存中为变量开辟空间时是需要时间的，尽管时间很短，但是在这段时间内CPU会处于空闲状态，因此就没有充分利用CPU。多线程就可以让CPU在JVM在内存开辟空间的这段时间去执行其他程序，从而提高CPU的利用率。

一、多线程的三种实现方式

1.继承Thread类

步骤如下：

1. 自己定义一个类继承Thread
2. 重写run方法
3. 创建自己写的类的对象，并启动线程（start方法用来启动线程）

public class MyThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(getName() + "HelloWorld!");}}
}

public class ThreadDemo1 {public static void main(String[] args) {/*多线程的第一种启动方式1.自己定义一个类继承Thread2.重写run方法3，创建子类的对象，并启动线程(start方法用来启动线程)*///这里设置两个线程，来看线程是不是交替执行的MyThread mt1 = new MyThread();MyThread mt2 = new MyThread();//设置线程的名字//setName方法是直接继承于Thread类的mt1.setName("线程1");mt2.setName("线程2");mt1.start();mt2.start();}
}

通过结果我们可以发现，在多线程模式下，两个线程是会交替执行的，充分利用CPU。

2.实现Runnable接口

步骤如下：

1. 定义一个类实现Runnable接口
2. 重写里面的run方法
3. 创建自己类的对象
4. 创建一个Thread对象，然后将自己类的对象传入，并开启线程。

public class MyRun implements Runnable{@Overridepublic void run() {for (int i = 0; i < 100; i++) {//获取当前线程的对象Thread t = Thread.currentThread();//因为不能直接使用Thread里面的方法，所以必须先获取当前进程，才可以获取名字System.out.println(t.getName() + "HelloWorld");}}
}

public class ThreadDemo {public static void main(String[] args) {/*多线程的第二种启动方式1.自己定义一个类实现Runnable接口2.重写里面的run方法3.创建自己的类的对象4.创建一个Thread类的对象，并开启线程*///创建MyRun对象//表示多线程要执行的任务MyRun mr = new MyRun();//创建线程对象//两个线程执行同一个任务Thread t1 = new Thread(mr);Thread t2 = new Thread(mr);//设置名字t1.setName("线程1");t2.setName("线程2");t1.start();t2.start();}
}

3.利用Callable接口和Future接口

前两种方式中的run方法没有返回值，所以前两种方式就无法获取多线程运行的结果，只能在控制台打印信息。 而第三种方式就可以获取到多线程运行的结果。

步骤如下：

1. 创建一个类实现Callable接口
2. 重写call方法（有返回值，表示多线程运行的结果）
3. 创建自己类的对象（表示多线程要执行的任务）
4. 创建FutureTask的对象（ 作用是管理多线程运行的结果）
5. 创建Thread类的对象，并启动线程

//Callable接口存在泛型，表示多线程返回值的类型
public class MyCallable implements Callable<Integer> {@Overridepublic Integer call() throws Exception {int sum = 0;for (int i = 1; i <= 100; i++) {sum += i;}return sum;}
}

public class ThreadDemo {public static void main(String[] args) throws ExecutionException, InterruptedException {/*多线程的第三种实现方式：特点：可以获取到多线程运行的结果1.创建一个类MyCallable实现Callable接口2.重写call方法（有返回值，表示多线程运行的结果）3.创建MyCallable的对象（表示多线程要执行的任务）4.创建FutureTask的对象（作用是管理多线程运行的结果）5.创建Thread类的对象，并启动线程*/MyCallable mc = new MyCallable();FutureTask<Integer> ft = new FutureTask<>(mc);//启动线程Thread t = new Thread(ft);t.start();//打印结果//要先启动线程，否则打印不出来结果，虚拟机会一直运行System.out.println(ft.get());}
}

4.三种方式对比

二、常见的成员方法

1.getName、setName、currentThread、sleep

getName方法是用来获取线程的名字，但是如果不给线程设置名字，那么默认的名字是什么呢？

如果我们没有给线程设置名字，线程也是有默认名字的。格式：Thread-X（X是序号，从0开始）。

public class MyThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(getName() + "@" + i);}}
}

public class ThreadDemo1 {public static void main(String[] args) {MyThread t1 = new MyThread();MyThread t2 = new MyThread();System.out.println(t1.getName());System.out.println(t2.getName());}
}

我们可以直接通过setName方法对线程设置名字，我们也可以直接通过构造方法来设置名字。但是我们自己写的类没有办法继承父类的构造方法，所以只能自己写一个带参数的构造方法，通过super关键字来调用父类的构造方法。

public class MyThread extends Thread{public MyThread(String name) {super(name);}public MyThread() {}@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(getName() + "@" + i);}}
}

public class ThreadDemo1 {public static void main(String[] args) {MyThread t1 = new MyThread("坦克");MyThread t2 = new MyThread("飞机");t1.start();t2.start();}
}

currentThread()方法是静态方法，我们在main方法中直接调用可以获取到执行main方法的那条线程。可以发现执行main方法的线程名字就是“main”。main线程的作用就是去调用main方法，并执行里面的代码。 哪个线程执行到currentThread()方法，就会获取到哪个线程。

public class ThreadDemo1 {public static void main(String[] args) {/*static Thread currentThread()           获取当前线程的对象*/Thread t = Thread.currentThread();System.out.println(t.getName());}
}

sleep方法也是静态方法，哪条线程执行到这个方法，那么哪条线程就会在这里停留对应的时间。方法的参数，就表示睡眠的时间，单位是ms。时间到了之后，线程就是自动醒来，继续执行下面的代码。

public class ThreadDemo1 {public static void main(String[] args) throws InterruptedException {/*static void sleep(long time)            让线程休眠指定的时间，单位为毫秒*/System.out.println("11");Thread.sleep(1000);System.out.println("22");}
}

先打印11后，线程会停留1s才会打印22。

2.线程的优先级

Java中对线程的调度是抢占式调度，强调一个随机性。CPU在什么时候执行哪条线程是不确定的，优
先级越高，随机到的概率也就越大。Java中优先级最小为1，最大为10，如果没有设置，那么默认
优先级为5。

public class MyRunnable implements Runnable{@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + "@" + i);}}
}

public class ThreadDemo2 {public static void main(String[] args) {/*final int getPriority()             获取线程的优先级*/MyRunnable mr = new MyRunnable();Thread t1 = new Thread(mr, "坦克");Thread t2 = new Thread(mr, "飞机");System.out.println(t1.getPriority());System.out.println(t2.getPriority());}
}

可以看到，默认的线程优先级为5。

对于setPriority方法，t1我设置优先级为1，t2设置优先级为10，只能说t2抢占CPU的概率较大。

public class ThreadDemo2 {public static void main(String[] args) {/*setPriority(int newPriority)        设置线程的优先级*/MyRunnable mr = new MyRunnable();Thread t1 = new Thread(mr, "坦克");Thread t2 = new Thread(mr, "飞机");t1.setPriority(1);t2.setPriority(10);t1.start();t2.start();}
}

两次的运行结果可以看出来，优先级低的线程也是有可能先执行完的，只不过概率低罢了。

3.守护线程

我们可以将一个线程设置为守护线程，当其他的非守护线程执行完毕之后，守护线程会陆续结束。（守护线程不会立马就停止，可能会再继续运行一段时间才结束）。

应用场景：

例如当两个人利用qq正在聊天，A要给B发一个文件，那么这个时候我们可以吧聊天窗口看作是一个线程，发送的文件也可以看作是一个线程。如果说把聊天窗口（线程1）给关掉了，线程2也就没有存在的必要了，此时就可以把传输文件设置为守护线程。

有下面的两个线程，将第二个线程设置为守护线程，可以发现在非守护线程执行完后，守护线程没有执行完毕，而是执行了一点就停止了。

public class MyThread1 extends Thread{@Overridepublic void run() {for (int i = 1; i <= 5; i++) {System.out.println(getName() + "----" + i);}}
}

public class MyThread2 extends Thread{@Overridepublic void run() {for (int i = 1; i <= 20; i++) {System.out.println(getName() + "----" + i);}}
}

public class ThreadDemo3 {public static void main(String[] args) {/*final void setDaemon(boolean on)            设置为守护线程*/MyThread1 t1 = new MyThread1();MyThread2 t2 = new MyThread2();t1.setName("女神");t2.setName("备胎");//设置为守护线程t2.setDaemon(true);t1.start();t2.start();}
}

4.插入线程

插入线程是为了让某个线程先于另一个线程执行完。

public class MyThread extends Thread{public MyThread(String name) {super(name);}public MyThread() {}@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(getName() + "@" + i);}}
}

public class ThreadDemo4 {public static void main(String[] args) throws InterruptedException {/*public final void join()            插入线程*/MyThread t = new MyThread();t.setName("土豆");t.start();//表示把t这个线程，插入到当前线程之前//当前线程是main线程t.join();for (int i = 0; i < 10; i++) {System.out.println("main线程" + i);}}
}

确实是土豆线程先于main线程执行。

三、线程安全

1.线程的生命周期

线程的一个周期内有五种状态

2.同步代码块

现在有如下的需求：

某电影院正在售卖电影票，一共有100张票，共有三个窗口售卖，设计一个程序模拟电影院卖票。

public class MyThread extends Thread{//该类的所有对象都共享同一个变量static int ticket = 0;@Overridepublic void run() {while (true) {if (ticket < 100) {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket++;System.out.println(getName() + "正在卖第" + ticket + "张票");}else {break;}}}
}

public class ThreadSafeDemo1 {public static void main(String[] args) {MyThread t1 = new MyThread();MyThread t2 = new MyThread();MyThread t3 = new MyThread();t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}
}

通过上述代码运行之后，会发现有一些问题，不同的窗口会出现卖的票相同的情况。这是由于线程抢夺CPU的随机性导致的。窗口1卖出之后还没来得及打印CPU就被窗口3线程抢走，最后导致数据的错误。

为了避免上述的问题，此时就需要用到同步代码块。它可以把能被操作的共享数据锁起来，只有等一个线程解锁之后，另一个线程才可以对共享数据进行操作。不过当线程出来之后，它也可以继续抢夺CPU的使用权。所以一个线程也可以多次执行。类比于上厕所。

特点：

1. 锁默认打开，有一个线程进去了，锁自动关闭
2. 里面的代码全部执行完毕，线程出来，锁自动打开
   

对于同步代码块中传入的锁对象，必须要确保是唯一的，所以一般使用当前类的字节码文件来当做参数进行传入。

public class MyThread extends Thread{//该类的所有对象都共享同一个变量static int ticket = 0;@Overridepublic void run() {while (true) {synchronized (MyThread.class) {if (ticket < 100) {try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket++;System.out.println(getName() + "正在卖第" + ticket + "张票");}else {break;}}}}
}

public class ThreadSafeDemo1 {public static void main(String[] args) {MyThread t1 = new MyThread();MyThread t2 = new MyThread();MyThread t3 = new MyThread();t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}
}

可以发现没有个重复票的情况。到最后，线程3一直抢夺到CPU的使用权。

3.同步方法

同步方法就是把synchronized关键字加到方法上。

特点：

1. 同步方法是锁住方法里面所有的代码。
2. 锁对象不能自己指定。如果方法是非静态的，锁对象就是this（当前方法的调用者）；如果方式静态的，那么锁对象就是当前类的字节码文件。

method方法是一个同步方法。

public class MyRunnable implements Runnable{int ticket = 0;@Overridepublic void run() {while (true) {if (method()) break;}}private synchronized boolean method() {if (ticket == 100) {return true;}else {try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket++;System.out.println(Thread.currentThread().getName() + "卖出第" + ticket + "张票");}return false;}
}

public class ThreadSafeDemo2 {public static void main(String[] args) {MyRunnable mr = new MyRunnable();Thread t1 = new Thread(mr, "窗口1");Thread t2 = new Thread(mr, "窗口2");Thread t3 = new Thread(mr, "窗口3");t1.start();t2.start();t3.start();}
}

4.lock锁

synchronized关键字加的锁是自动打开和释放的，如果想要手动的去加锁和释放锁，就需要一个新的锁对象Lock。

Lock中提供了获得锁和释放锁的方法：
void lock（） 获得锁
void unlock（） 释放锁

Lock是接口 ，不可以直接实例化，只能用它的实现类ReentrantLock来实例化。

public class MyThread extends Thread{static int ticket = 0;//创建锁对象static Lock lock = new ReentrantLock();@Overridepublic void run() {while (true) {lock.lock();if (ticket == 100) {break;}else {try {Thread.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket++;System.out.println(getName() + "卖出第" + ticket + "张票");}lock.unlock();}}
}

public class ThreadSafeDemo3 {public static void main(String[] args) {MyThread t1 = new MyThread();MyThread t2 = new MyThread();MyThread t3 = new MyThread();t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}
}

上述代码会出现一些问题，当卖到100张票时程序并没有停止运行。这是因为发生了死锁现象，当窗口2线程执行到ticket==100时，会直接跳出循环，以至于后面的lock.unlock()释放锁代码没有执行，导致窗口1和窗口3线程会一直停留在lock.lock() 这句代码处，导致程序无法停止。

为了解决上述问题，我们可以利用try…catch…finally结构，将释放锁的代码写到finally部分（finally中的代码是一定会执行的）。

public class MyThread extends Thread{static int ticket = 0;//创建锁对象static Lock lock = new ReentrantLock();@Overridepublic void run() {while (true) {//加锁lock.lock();try {if (ticket == 100) {break;}else {Thread.sleep(10);ticket++;System.out.println(getName() + "卖出第" + ticket + "张票");}} catch (InterruptedException e) {throw new RuntimeException(e);} finally {//释放锁lock.unlock();}}}
}

public class ThreadSafeDemo3 {public static void main(String[] args) {MyThread t1 = new MyThread();MyThread t2 = new MyThread();MyThread t3 = new MyThread();t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}
}

结果正确。