多线程详解
多任务
多线程
进程(Process)、线程(Thread)
在操作系统中运行的程序就是进程，比如你的QQ，游戏，腾讯视频等。。。
在一个应用程序里可以同时做很多事情就线程，一个进程里有多个线程。比如播放器这个应用，它可以播放声音的同时可以有图片显示，还有字幕显示，一个线程控制一个功能。
线程就是独立的执行路径；
在程序运行时，即使没有自己创建线程，后天也会有多个线程，如主线程，gc线程；
main（）称为主线程，为系统的入口，用于执行整个程序；
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。
对同一份资源操作时，如CPU调度时间，并发控制开销。
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致.
注意：很多多线程是模拟出来的，真正的多线程是指由多个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值执行一个（因为是单核）
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);
}
}
}
与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方法出现问题！");
}
}
}
}
小结：
继承Thread
实现Runnable接口
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（时间）指定当前线程阻塞的毫秒数（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();
}
}
}
（查看JDK帮助文档）
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有进程，线程调度器按优先级决定应该调度哪个线程来执行
线程的优先级用数字来表示，范围从1-10
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度
使用以下方式获得或者改变优先级
优先级的设定建议在start调度之前
线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
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）,当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可（就像你上厕所要把门锁上，外面的人要等你打开门才能进去）。存在以下问题：
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（）会释放锁。
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现死锁之后，不会出现异常，不会出现提示，知识所有的线程都持于阻塞状态，无法继续
专门的算法、原则
尽量减少同步资源的定义
尽量避免嵌套同步
java提供了更强大的线程同步机制——通过显示定义同步锁对象实现同步。同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口时控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问资源之前应先获得Lock对象
ReentrantLock类（可重入锁）实现了Lock，它拥有synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可显示加锁，释放锁。
Lock是显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且有较好的扩展性（提供更多的类）
优先使用顺序：
Lock>同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）
原文：https://www.cnblogs.com/mjjh/p/13495770.html