多线程详解
一、线程的简介
任务、进程、线程、多线程
多任务
- 比如一边吃饭，一边玩手机；一边上厕所一边玩手机；现实生活中太多这样同时做多件事情的例子了，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事情。
多线程
- 原来是一条路，慢慢遗忘车太多，道路堵塞，效率极低。为了提高使用效率，能够充分利用道路，于是加了多个车道，从此，妈妈再也不用担心道路堵塞了。
进程(Process)、线程(Thread)
在操作系统中运行的程序就是进程，比如你的QQ，游戏，腾讯视频等。。。
在一个应用程序里可以同时做很多事情就线程，一个进程里有多个线程。比如播放器这个应用，它可以播放声音的同时可以有图片显示，还有字幕显示，一个线程控制一个功能。
核心概念
-
线程就是独立的执行路径；
-
在程序运行时，即使没有自己创建线程，后天也会有多个线程，如主线程，gc线程；
-
main（）称为主线程，为系统的入口，用于执行整个程序；
-
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。
-
对同一份资源操作时，如CPU调度时间，并发控制开销。
-
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致.
线程的创建
线程的创建方式 1.继承Thread类
注意：很多多线程是模拟出来的，真正的多线程是指由多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的块，所以就有同时执行的错觉。
package com.mjh.thread;
/**
* 注意：线程开启不是立即执行，有CPU调度执行
*
*/
public class TestThread1 extends Thread{
@Override
public void run() {
//run方法线程体
for (int i = 0; i <200 ; i++) {
System.out.println("我在看电视----"+i);
}
}
public static void main(String[] args) {
//main线程，主线程
//创建一个线程对象
TestThread1 testThread1 = new TestThread1();
//调用start（）方法开启线程
testThread1.start();
for (int i = 0; i < 500; i++) {
System.out.println("我在上厕所-----"+i);
}
}
}
虽然是同时执行的，但是每一次CPU值执行一个（因为是单核）
2. 实现Runnable接口
package com.mjh.thread;
/**
* 创建线程方法2:实现runnable接口，重写run方法，
* 执行线程需要丢入runnable接口实现类，调用start（）
*/
public class TestThread3 implements Runnable{
@Override
public void run() {
//run方法线程体
for (int i = 0; i <200 ; i++) {
System.out.println("我在看电视----"+i);
}
}
public static void main(String[] args) {
//创建runnable接口的实现类对象
TestThread3 testThread3 = new TestThread3();
//创建线程对象，通过线程对象来开启我们的线程，代理
/* Thread thread = new Thread(testThread3);
thread.start();
*/
new Thread(testThread3).start();
for (int i = 0; i < 500; i++) {
System.out.println("我在上厕所-----"+i);
}
}
}
3.实现Callable方法
与Runnable相比，Callable功能更加强大些
-
相比于run方法，可以有返回值
-
方法可以抛出异常
-
支持泛型的返回值
-
需要借助FunturnTask类，比如获取返回值结果
package com.mjh.thread; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; import java.util.concurrent.*; public class TestCallable6 implements Callable<Boolean> { private String url;//网络图片名 private String name;//保存的文件名 public TestCallable6(String url, String name){ this.url=url; this.name=name; } @Override public Boolean call() { WebDownloader webDownloader = new WebDownloader(); webDownloader.downloader(url,name); System.out.println("下载了文件名为："+name); return true; } public static void main(String[] args) throws ExecutionException, InterruptedException { TestCallable6 t1 = new TestCallable6("http://inews.gtimg.com/newsapp_match/0/8677586534/0","1.jpg"); TestCallable6 t2 = new TestCallable6("http://pic.962.net/up/2017-12/20171218154534653750.jpg","2.jpg"); //创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(2); //提交执行 Future<Boolean> r1 = ser.submit(t1); Future<Boolean> r2 = ser.submit(t2); //提交结果 Boolean rs1 = r1.get(); Boolean rs2 = r1.get(); //关闭服务 ser.shutdownNow(); } //下载器 class WebDownloader{ public void downloader(String url,String name) { try { FileUtils.copyURLToFile(new URL(url),new File(name)); } catch (IOException e) { e.printStackTrace(); System.out.println("IO异常，download方法出现问题！"); } } } }
4.使用线程池
- 背景：经常创建和销毁，使用量特别大资源，不如并发情况下的线程，对性能影响很大
- 思路：提前创建好多个线程，放入线程池中，使用是直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
- 好处：
- 提高响应速度（减少创建子新线程的时间）
- 降低资源消耗（重复利用线程池线程，不需要每次都创建）
- 便于线程管理
小结：
继承Thread
- 子继承Thread类具备多线程能力
- 启动线程：子类对象.start()
- 不建议使用：避免OOP单继承局限性
实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程：传入目标对象+Thread对象.start()
- 推荐使用，避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
初始并发问题
package com.mjh.thread;
/**
* 多个线程同时操作同一个对象
* 买火车票的例子
*/
public class TestThread4 implements Runnable {
//票数
private int ticketNums=10;
@Override
public void run() {
while(true){
if(ticketNums<=0){break;}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"--->拿到第"+ticketNums--+"票");
}
}
//一个资源多个线程拿
public static void main(String[] args) {
TestThread4 testThread4 = new TestThread4();
new Thread(testThread4,"小明").start();
new Thread(testThread4,"小红").start();
new Thread(testThread4,"黄牛党").start();
}
}
并发问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱。（解决办法：同步）
案例：龟兔赛跑
package com.mjh.thread;
public class TestThread5 implements Runnable {
private static String winner;
@Override
public void run() {
for (int i = 0; i <=100 ; i++) {
//模拟兔子休息,每10米休息一下
if(Thread.currentThread().getName().equals("兔子")&& i%10==0){
try {
Thread.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag = gameOver(i);
if (flag){break;}
System.out.println(Thread.currentThread().getName()+"---->跑了"+i+"米");
}
}
//判断是否比赛结束
private boolean gameOver(int rice){
if(winner!=null){return true; }
{
if (rice >= 100) {
winner = Thread.currentThread().getName();
System.out.println("winner is " + winner);
return true;
}
}
return false;
}
public static void main(String[] args) {
TestThread5 race = new TestThread5();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
线程状态
线程休眠(sleep)
-
sleep（时间）指定当前线程阻塞的毫秒数（1000毫秒=1秒）
-
sleep存在异常InterruptedException
-
sleep时间达到后线程进入就绪状态
-
sleep可以模拟网络延迟时，倒计时等
-
每一个对象都有一个锁，sleep不会释放锁
举例：计时
package com.mjh.thread; import java.text.SimpleDateFormat; import java.util.Date; public class TestSleep{ public static void main(String[] args) { try { tenDown(); } catch (InterruptedException e) { e.printStackTrace(); } } //模拟倒计时 public static void tenDown() throws InterruptedException { int num=10; while(true){ Thread.sleep(1000); System.out.println(num--); if(num<=0){ break; } } } }
package com.mjh.thread;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestSleep2{
public static void main(String[] args) {
//打印当前系统时间
Date startTime=new Date(System.currentTimeMillis());//获取当前系统时间
try {
while(true){
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime=new Date(System.currentTimeMillis());
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程礼让（yield）
- 礼让线程，让当前正在执行的线程暂停，但不阻塞
- 将线程从运行状态转为就绪状态
- 让CPU重新调度，礼让不一定成功，看CPU心情
线程强制执行(join)
- join合并线程，待此线程执行完成之后，再执行其他线程，其他线程阻塞
- 可以想象成插队
线程状态观测
（查看JDK帮助文档）
线程优先级
-
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有进程，线程调度器按优先级决定应该调度哪个线程来执行
-
线程的优先级用数字来表示，范围从1-10
- Thread.MIN_PRIORITY=1;
- Thread.MAX_PRIORITY=10;
- Thread.MORM_PRIORITY=5;
-
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度
-
使用以下方式获得或者改变优先级
- getPriority()，setPriority(int xxx)
-
优先级的设定建议在start调度之前
守护(Daemon)线程
-
线程分为用户线程和守护线程
-
虚拟机必须确保用户线程执行完毕
-
虚拟机不用等待守护线程执行完毕
package com.mjh.thread; public class TestDemon { public static void main(String[] args) { God god = new God(); You you = new You(); Thread thread = new Thread(god); thread.setDaemon(true);//默认是false表示用户线程，正常的线程都是用户线程 thread.start();//上帝 守护线程启动 new Thread(you).start();//你 用户线程启动 } //上帝 static class God implements Runnable{ @Override public void run() { while (true){ System.out.println("上帝保佑着你"); } } } //你 static class You implements Runnable{ @Override public void run() { for (int i = 0; i <36500 ; i++) { System.out.println("你一生都开心的活着"); } System.out.println("-=======goodbye!world!"); } } }
解决线程安全问题的方式
1.同步方法
2.同步代码块
3.Lock（锁）
线程同步机制
多个线程操作同一个资源
并发
同一个对象被多个线程同时操作
线程同步（synchronized）
- 现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是：排队，一个一个来（队列）
-
处理多线程问题时，多个线程访问同一个对象（并发），并且某些线程还想修改这个对象。
这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程在使用
-
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入了锁机制（synchronized）,当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可（就像你上厕所要把门锁上，外面的人要等你打开门才能进去）。存在以下问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起（影响性能）
- 在多线程竞争下，加锁，释放锁会导致比较多分上下文切换和调度延时，引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级导致，引起性能问题。
同步方法
public synchronized void method(int srgs){}
-
synchronized方法控制对“对象”的访问，每个对象对象一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行（例如上厕所）
-
缺陷：若将一个大的方法申明为synchronized将会影响效率
同步代码块
synchronized(obj){}
-
Obj称为同步监视器
-
obj可以是任何对象，但是推荐使用共享资源作为同步监视器
-
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this,就是这个对象本身，或者class
-
sleep()和wait()的区别？
1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
2.不同点：1）两个方法声明的位置不同，Thread类中声明sleep（）， Object类中声明wait（）
2）调用的要求不同：sleep（）可以在任意需要的场景下调用，wait（）必须使用在同步代码块或者同步方法中
3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或者同步方法中，sleep（）不会释放锁，wait（）会释放锁。
死锁
-
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
-
出现死锁之后，不会出现异常，不会出现提示，知识所有的线程都持于阻塞状态，无法继续
解决方法
-
专门的算法、原则
-
尽量减少同步资源的定义
-
尽量避免嵌套同步
Lock(锁)
-
java提供了更强大的线程同步机制——通过显示定义同步锁对象实现同步。同步锁使用Lock对象充当
-
java.util.concurrent.locks.Lock接口时控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问资源之前应先获得Lock对象
-
ReentrantLock类（可重入锁）实现了Lock，它拥有synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可显示加锁，释放锁。
synchronized 和Lock的对比
-
Lock是显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
-
Lock只有代码块锁，synchronized有代码块锁和方法锁
-
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且有较好的扩展性（提供更多的类）
-
优先使用顺序：
Lock>同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）