浅谈多线程

听源哥的歌

于 2021-05-18 15:52:40 发布

阅读量96

点赞数

分类专栏： java基础文章标签： java 多线程

本文链接：https://blog.csdn.net/qq_41740469/article/details/115469456

版权

java基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1、进程？线程？多任务？
电脑中运行着很多软件程序，如QQ、微信、浏览器、酷狗音乐、优酷视频等等，每个软件其实就是一个进程。而线程则是进程中的一个分支或者说现象就是独立的执行路径。一个进程中至少包括一个线程。线程可以理解为提高程序运行的效率，或者各司其职，如QQ中既可以同时打字聊天也可以语音，再比如高速路有三个车道，车辆就可以同时跑，充分利用道路，大大提高了通行效率。
2、线程的创建方式
常用的线程创建方式有Thread、Runnable、Callable、线程池。
官方对于Thread的描述：
在这里插入图片描述
2.1 Thread创建线程的步骤：

.自定义线程类继承Thread
.重写run()方法，编写线程执行程序体
.创建线程对象，调用start()方法启动线程。

2.1.1 MyThreadt测试

package com.thread;

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <30 ; i++) {
            System.out.println("子线程运行:"+i);
        }
    }
}

package com.test;

import com.thread.MyThread;

public class CommonTest {
    public static void main(String[] args) {
    	//自定义的线程
        MyThread myThread = new MyThread();
        myThread.start();

		//main 线程
        for (int i = 0; i < 500; i++) {
            System.out.println("主线程运行：" + i);
        }
    }
}

2.1.2 多线程下载图片
1、导入jar
2、创建下载类
3、自定义线程类

 <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>

package com.test;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

/**
 * 自定义下载类
 */
public class WebDownload {
//下载方法
    public void downloadFile(String url, String fileName) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(fileName));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件下载失败");
        }
    }

}

package com.thread;

import com.test.WebDownload;
//多线程同步下载图片
public class DownloadThread extends Thread {
    //网络图片地址
    private String url;
    //文件名
    private String name;

    public DownloadThread(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public void run() {
        WebDownload webDownload = new WebDownload();
        webDownload.downloadFile(url, name);
        System.out.println("下载了文件，文件名：" + name);
    }

    public static void main(String[] args) {
        DownloadThread downloadThread=new DownloadThread("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e","zhangjianing");
        DownloadThread downloadThread2=new DownloadThread("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e","zhangjianing2");
        DownloadThread downloadThread3=new DownloadThread("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e","zhangjianing3");
        downloadThread.start();
        downloadThread2.start();
        downloadThread3.start();
    }
}

下载成功
在这里插入图片描述
2.2 实现Runnable接口步骤

  .自定义类实现Runnable接口
  .实现接口中的run()方法，方法中编写线程执行体
  .创建线程对象，调用start()方法,启动线程。

官方文档释义：
在这里插入图片描述

2.2.1 RunableDemo

package com.runnable;
//实现Runnable接口，重写run方法，
public class MyRunnable implements Runnable {
    public void run() {//线程核心执行体
        for (int i = 0; i < 20; i++) {
            System.out.println("子线程运行：" + i);
        }
    }
}

public class CommonTest {
    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        MyRunnable myRunnable = new MyRunnable();
        //本身Thread也是实现了Runnable接口的。
        Thread thread = new Thread(myRunnable);
        //调用start方法，启动线程
        thread.start();
        for (int i = 0; i < 50; i++) {
            System.out.println("主线程运行：" + i);
        }
    }

继承Thread类和实现Runnable接口的区别

* 继承Thread类
1、子类继承Thread类具备多线程能力
2、启动线程:子类对象.start()
3、不建议使用:避免OOP单继承局限性。
* 实现Runable接口
1、实现接口Runnable具有多线程能力
2、启动线程，传入目标对象+Thread对象.start()
3、建议使用Runnable，避免了单继承的局限性，灵活方便，方便同一个对象被多个线程使用。

2.2.2 多线程实现买火车票

package com.runnable;

//实现Runnable接口，重写run方法，
public class MyRunnable implements Runnable {
    //总票数
    private int ticket = 100;

    public void run() {//线程核心执行体
        while (ticket>0) {
            System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
            //每一个线程卖出一张票，就减 一张票
            ticket--;
        }
    }
}

public class CommonTest {
    public static void main(String[] args) {
        //线程1 模拟卖票
        MyRunnable myRunnable = new MyRunnable();
        
        Thread thread = new Thread(myRunnable);
        thread.start();
        
        //线程2 模拟卖票
        Thread thread2 = new Thread(myRunnable);
        thread2.start();
        //线程3 模拟卖票
        Thread thread3 = new Thread(myRunnable);
        thread3.start();

        //线程4 模拟卖票
        Thread thread4 = new Thread(myRunnable);
        thread4.start();
    }

控制台输出

Thread-0正在售卖第100张票
Thread-0正在售卖第99张票
Thread-0正在售卖第98张票
Thread-0正在售卖第97张票
Thread-0正在售卖第96张票
Thread-0正在售卖第95张票
Thread-0正在售卖第94张票
Thread-3正在售卖第100张票
Thread-1正在售卖第100张票
Thread-1正在售卖第99张票
Thread-1正在售卖第98张票
Thread-1正在售卖第97张票
Thread-1正在售卖第96张票
Thread-1正在售卖第95张票
Thread-1正在售卖第94张票
Thread-1正在售卖第93张票
Thread-1正在售卖第92张票
Thread-2正在售卖第100张票
Thread-1正在售卖第91张票
Thread-3正在售卖第99张票
Thread-0正在售卖第93张票

此时发现了问题线程0 、线程 3 、线程2 都卖出了第100号票，这说明多个线程同时操作一个资源的情况下，线程不安全，有严重的数据问题。这个问题待会解决。

2.3 实现Callable接口步骤

1、实现Callable接口,需要返回值类型
2、重写call方法，需要抛出异常
3、创建目标对象
4、创建执行服务：ExecutorService es=new Executors.newFixedThreadPool(1);
5、提交执行：Future<Boolean> result=es.submit(1);
6、获取结果：boolean flag=result.get();
7、关闭服务:es.shutdownNow();

2.3.1 实现Callable接口多线程下载图片

package com.test;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

/**
 * 自定义下载类
 */
public class WebDownload {
//下载方法
    public void downloadFile(String url, String fileName) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(fileName));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件下载失败");
        }
    }

}

package com.callable;

import com.test.WebDownload;

import java.util.concurrent.Callable;

public class MyCallable implements Callable {
    private String url;
    private String name;

    public MyCallable(String url, String name) {
        this.url = url;
        this.name = name;
    }

    public Boolean call() throws Exception {
        //
        WebDownload webDownload = new WebDownload();
        //根据文件url和文件名 下载文件
        webDownload.downloadFile(url,name);
        return true;
    }
}

public class CommonTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        MyCallable myCallable = new MyCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e", "zhangjianing2021");
        MyCallable myCallable2 = new MyCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e", "zhangjianing2022");
        MyCallable myCallable3 = new MyCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201901%2F24%2F20190124212555_aAzHh.thumb.700_0.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1620823150&t=52bd044f2ba560bfe9ca51bb1b07221e", "zhangjianing2023");

        //创建执行服务
        ExecutorService es = Executors.newFixedThreadPool(3);

        //提交执行
        Future<Boolean> submit = es.submit(myCallable);
        Future<Boolean> submit2 = es.submit(myCallable2);
        Future<Boolean> submit3 = es.submit(myCallable3);

        //获取结果
        boolean r = submit.get();
        boolean r2 = submit2.get();
        boolean r3 = submit3.get();
        //关闭服务
        es.shutdown();
    }

3、线程状态
线程状态一共分为创建、就绪、阻塞、运行、死亡五种状态。

//线程执行顺序
Thread thread = new Thread();
1、线程对象一旦创建就进入新生状态
2、调用start()方法，线程进行就绪状态，但是并不意味着立即调度执行。
3、当调用sleep()、wait()或者同步锁定时,线程进入阻塞状态。当阻塞解除后，
	重新进入就绪状态，等待cpu调度。
4、进入运行状态，线程开始执行业务。
5、线程死亡。

在这里插入图片描述
3.1 线程核心方法

		//更新线程的优先级
	   .setPriority(int newPriority);
	  //指定的毫秒数内让当前正在执行的线程休眠
	   .static void sleep(long millis);
	   //等待该线程终止/合并线程
        .void join();
        //暂停当前正在执行的线程对象，
        //并执行其他线程 也叫线程礼让
        .static void yield();
        //中断线程，尽量不要使用这个方法。
        .void interrupt();
        //测试线程是否处于活动状态
        .boolean isAlive()

3.1 停止/终止线程
目前不建议大家使用JDK官方提供的stop()、destroy()方法，文档表示此方法已废弃。
更多的建议让线程平滑的停下来，如设置标志位终止变量。
例：

public class StopRunnable implements Runnable {
    //线程定义 停止标记
    private boolean flag = true;

    //对外提供停止线程方法
    public void stop() {
        this.flag = false;
    }


    public void run() {
        int i =0;
        //线程中判断 标记
        while (flag) {
            System.out.println(Thread.currentThread().getName()+"Run.....");
        }
    }
}

    public static void main(String[] args) {
        StopRunnable stopRunnable = new StopRunnable();

        Thread thread = new Thread(stopRunnable);

        thread.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程："+i);
            if(i==900){
                //调用stop方法 切换标识符，停止线程
                stopRunnable.stop();
                System.out.println(Thread.currentThread().getName()+":线程停止了");
            }
        }
    }

3.2 线程休眠

1、sleep(long millils)指定当前线程阻塞的毫秒数
2、sleep存在异常InteruptedException;
3、sleep时间达到后，线程进入等待状态
4、sleep可以模拟网络延时,倒计时等。
5、每一个对象都有一个锁，但是sleep不会释放锁。

***售票模拟网路延时案例

public class Ticket implements Runnable {
	//总票数
    private static int ticket = 100;

    public void run() {
        while (ticket > 0) {
            try {
                //模拟延时2s
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "线程正在售卖第" + ticket-- + "张票");
        }
    }

    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        Thread thread = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        thread.start();
        thread2.start();
    }
}

**** 模拟倒计时案例

//模拟 倒计时Demo
public class CountdownTest implements Runnable {
    private static int num = 10;

    public void run() {
        while (num > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("num>>>>>:" + num--);
        }
    }

    public static void main(String[] args) {
        CountdownTest countdownTest = new CountdownTest();
        Thread thread = new Thread(countdownTest);
        thread.start();
    }
}

num>>>>>:10
num>>>>>:9
num>>>>>:8
num>>>>>:7
num>>>>>:6
num>>>>>:5
num>>>>>:4
num>>>>>:3
num>>>>>:2
Disconnected from the target VM, address: '127.0.0.1:12167', transport: 'socket'
num>>>>>:1

3.3 线程礼让

1、礼让线程，让当前正在执行的线程暂停，但是不阻塞。
2、将线程从运行的状态改为就绪状态
3、让cpu重新调度,礼让不一定能成功,看cpu心情。

线程礼让Demo

package com.demo;

//线程礼让 demo
public class YieldRunable implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();//礼让线程
        System.out.println(Thread.currentThread().getName() + "线程停止执行");
    }

    public static void main(String[] args) {
        YieldRunable yieldRunable = new YieldRunable();

        Thread thread = new Thread(yieldRunable);
        thread.setName("A");

        Thread thread2 = new Thread(yieldRunable);
        thread2.setName("B");

        thread.start();
        thread2.start();
    }
}

3.4 Join合并线程

Join合并线程,待此行程执行完毕后，在执行其他线程，其他线程阻塞。
比如银行VIP，或者说插队。只有vip办理完业务后，普通用户才可以办业务。

合并线程Join 案例

package com.demo;

public class JoinRunnable implements Runnable {

    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("Join>>>>>:" + i);
        }
    }


    public static void main(String[] args) throws InterruptedException {
        JoinRunnable joinRunnable = new JoinRunnable();

        Thread thread = new Thread(joinRunnable);
        thread.start();


        for (int i = 0; i < 100; i++) {
            if (i == 50) {
                thread.join();//主线程main阻塞，直到vip线程执行完毕，再去执行mian线程
            }
            System.out.println("mian>>>>>>>>:" + i);
        }
    }

}

果然看控制台输出，当mian中的i=50时线程被阻塞，vip合并（插队）了线程，并执行完毕自己的业务。

mian>>>>>>>>:0
Join>>>>>:0
Join>>>>>:1
Join>>>>>:2
Join>>>>>:3
Join>>>>>:4
Join>>>>>:5
Join>>>>>:6
Join>>>>>:7
Join>>>>>:8
Join>>>>>:9
mian>>>>>>>>:1
Join>>>>>:10
Join>>>>>:11
Join>>>>>:12
Join>>>>>:13
Join>>>>>:14
mian>>>>>>>>:2
Join>>>>>:15
mian>>>>>>>>:3
Join>>>>>:16
mian>>>>>>>>:4
mian>>>>>>>>:5
mian>>>>>>>>:6
mian>>>>>>>>:7
mian>>>>>>>>:8
mian>>>>>>>>:9
mian>>>>>>>>:10
Join>>>>>:17
Join>>>>>:18
Join>>>>>:19
mian>>>>>>>>:11
mian>>>>>>>>:12
mian>>>>>>>>:13
mian>>>>>>>>:14
mian>>>>>>>>:15
mian>>>>>>>>:16
mian>>>>>>>>:17
mian>>>>>>>>:18
mian>>>>>>>>:19
mian>>>>>>>>:20
mian>>>>>>>>:21
mian>>>>>>>>:22
mian>>>>>>>>:23
mian>>>>>>>>:24
mian>>>>>>>>:25
mian>>>>>>>>:26
mian>>>>>>>>:27
mian>>>>>>>>:28
mian>>>>>>>>:29
mian>>>>>>>>:30
mian>>>>>>>>:31
mian>>>>>>>>:32
mian>>>>>>>>:33
mian>>>>>>>>:34
mian>>>>>>>>:35
mian>>>>>>>>:36
mian>>>>>>>>:37
mian>>>>>>>>:38
Join>>>>>:20
mian>>>>>>>>:39
Join>>>>>:21
mian>>>>>>>>:40
Join>>>>>:22
mian>>>>>>>>:41
Join>>>>>:23
Join>>>>>:24
Join>>>>>:25
Join>>>>>:26
Join>>>>>:27
Join>>>>>:28
Join>>>>>:29
Join>>>>>:30
Join>>>>>:31
Join>>>>>:32
Join>>>>>:33
Join>>>>>:34
Join>>>>>:35
Join>>>>>:36
Join>>>>>:37
mian>>>>>>>>:42
Join>>>>>:38
Join>>>>>:39
Join>>>>>:40
Join>>>>>:41
Join>>>>>:42
Join>>>>>:43
Join>>>>>:44
Join>>>>>:45
Join>>>>>:46
Join>>>>>:47
Join>>>>>:48
mian>>>>>>>>:43
Join>>>>>:49
Join>>>>>:50
Join>>>>>:51
Join>>>>>:52
Join>>>>>:53
Join>>>>>:54
Join>>>>>:55
Join>>>>>:56
Join>>>>>:57
mian>>>>>>>>:44
mian>>>>>>>>:45
mian>>>>>>>>:46
mian>>>>>>>>:47
mian>>>>>>>>:48
mian>>>>>>>>:49   *********************
Join>>>>>:58      *********************
Join>>>>>:....
Join>>>>>:998
Join>>>>>:999     *********************
mian>>>>>>>>:...
mian>>>>>>>>:98
mian>>>>>>>>:99

3.5 线程状态观察

Thread.State 线程状态。线程可以处于以下状态之一
== New ==
尚未启动的线程处于此状态
== RUNNABLE ==
在java虚拟机中执行的状态处于此状态
== BLOCKED == 
被阻塞等待监视器锁定的线程处于此状态
== WAITING ==
正在等待另一个线程执行特定动作的线程处于此状态
== TIMED WAITING ==
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
== TERMINATED ==
已退出的线程处于此状态。

一个线程可以在给定时间点处于一个状态，这些状态是不反映任何操作系统线程
状态的虚拟机状态。

线程状态案例Demo

package com.demo;

public class ThreadState implements Runnable {

    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("///");
    }


    public static void main(String[] args) throws InterruptedException {
        ThreadState threadState = new ThreadState();

        Thread thread = new Thread(threadState);

        //观察状态 NEW
        Thread.State state = thread.getState();
        System.out.println(state);

        //线程启动    观察启动后 RUN
        thread.start();

        state = thread.getState();
        //Run 阶段
        System.out.println(state);

        //如果线程不停止，一直输出状态
        while (state != Thread.State.TERMINATED) {
            Thread.sleep(100);
            //更新状态
            state = thread.getState();
            //
            System.out.println(state);
        }
    }
}

3.6 线程优先级

1、Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，
线程调度器按照优先级决定应该调度哪个线程来执行。
2、线程的优先级用数字表示，范围从1~10
 2.1 Thread.MIN_PRIORITY=1
 2.2 Thread.MAX_PRIORITY=10
 2.3 Thread.NORM_PRIORITY=5
 使用一下方式改变或者获取优先级
 ... getPriority().setPriority(int xxx)

线程优先级案例Demo

package com.demo;

/**
 * 线程优先级
 */
public class ThreadPriority implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "....>>>" + Thread.currentThread().getPriority());
    }


    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName() + "....>>>" + Thread.currentThread().getPriority());
        ThreadPriority threadPriority = new ThreadPriority();

        Thread thread = new Thread(threadPriority);
        Thread thread2 = new Thread(threadPriority);
        Thread thread3 = new Thread(threadPriority);
        Thread thread4 = new Thread(threadPriority);
        Thread thread5 = new Thread(threadPriority);
        Thread thread6 = new Thread(threadPriority);

        //先设置优先级  然后启动
        thread.start();
        thread2.setPriority(1);
        thread2.start();

        thread3.setPriority(4);
        thread3.start();
        
        //MAX_PRIORITY =10
        thread4.setPriority(Thread.MAX_PRIORITY);
        thread4.start();

        thread5.setPriority(-1);
        thread5.start();

        thread6.setPriority(11);
        thread6.start();
    }
}

控制台报错。此时说明线程优先级低只是意味着获得调度的概率低，
并不是优先级低就不会被调用，要看CPU的调度。

Thread-0....>>>5
Thread-1....>>>1
Thread-2....>>>4
Thread-3....>>>10
java.lang.IllegalArgumentException
	at java.lang.Thread.setPriority(Thread.java:1089)
	at com.demo.ThreadPriority.main(ThreadPriority.java:34)

3.7 守护线程（daemon）

1、线程分为用户线程和守护线程
2、虚拟机必须确保用户线程执行完毕
3、虚拟机不用等待守护线程执行完毕，
如后台记录操作日志、监控内存、垃圾回收等..

守护线程案例Demo

package com.demo;

/**
 * 守护线程
 */
public class ThreadDaemon {
    public static void main(String[] args) {
        God god = new God();
        Perople perople = new Perople();
        Thread thread = new Thread(god);
        //默认false表示是用户线程  正常的线程都是用户线程
        thread.setDaemon(true);

        //上帝启动守护线程
        thread.start();


        Thread thread2 = new Thread(perople);
        //用户线程启动
        thread2.start();
    }


}

class God implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("哦天哪 我的上帝，保佑着子民");
        }

    }
}

class Perople implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("人们开心的 活着每一天");
        }
        System.out.println("====googbybe world ===");
    }
}

3.8 并发
并发：同一个对象或者同一个资源被多个线程同时操作。如抢票、两个银行同时取钱、共享打印机、或者在学校餐厅打饭等。

	线程不安全的产生原因：
	**由于同一个进程的多个线程共享同一块存储空间，在带来方便的同时，也带来
	了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入
	锁机制synchronized,当一个线程获得对象的排它锁，独占资源，其他线程
	必须等待，使用后释放锁即可，存在以下问题
	1、一个线程持有锁会导致其他所有需要此锁的线程挂起。
	2、在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，
	引起性能问题。
	3、如果一个优先级高的线程等待一个优先级低的线程释放锁(例 一个厕所，
	优先级高的只是小便一下，优先级低的却是拉肚子占着门插销资源，
	只有优先级低的释放完锁，优先级高的才能去小便，可能尿了裤子哈) 
	会导致优先级导致，引起性能问题。

.
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池行成队列（相对于排队），等待前面线程使用完毕，下一个线程再使用。

#模拟并发下多线程购票不安全案例

//重现线程不安全问题
public class TicketRunnable implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + ":正在售卖第" + ticket-- + ":票");
        }
    }

    public static void main(String[] args) {
        TicketRunnable ticketRunnable = new TicketRunnable();

        Thread thread = new Thread(ticketRunnable);
        Thread thread2 = new Thread(ticketRunnable);
        Thread thread3 = new Thread(ticketRunnable);

        thread.start();
        thread2.start();
        thread3.start();
    }
}

此时三个线程共享icket变量，并发下产生问题（卖出了同一张票，甚至有负票），如控制台打印

Thread-1:正在售卖第100:票
Thread-2:正在售卖第100:票
Thread-0:正在售卖第100:票
Thread-2:正在售卖第99:票
Thread-1:正在售卖第99:票
Thread-2:正在售卖第98:票
Thread-0:正在售卖第99:票
Thread-2:正在售卖第97:票
Thread-1:正在售卖第98:票
Thread-2:正在售卖第96:票
Thread-0:正在售卖第98:票
Thread-2:正在售卖第95:票
Thread-1:正在售卖第97:票
Thread-2:正在售卖第94:票
Thread-0:正在售卖第97:票
......................
Thread-2:正在售卖第-1:票

线程不安全的集合案例

public class UnsafeCollection {
    public static void main(String[] args) {
    //线程不安全的集合
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
            System.out.println(list.size());
        }
    }
}

控制台输出只有9996个。

4 解决并发下线程不安全问题。
4.1 同步方法

1、由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们
只需要针对方法提出一套机制,这套机制就是synchronized关键字
语法 ：public synchronized void method(int args){}
synchronized方法控制对"对象"的访问，也就是每个对象对应一把锁，
每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程被阻塞,
方法一旦执行,就独占该锁，直到该方法返回才释放锁,后面被阻塞的线程才能
获得这个锁，继续执行。

同步的前提：
1、 必须要有两个或者两个以上的线程
2、必须是多个线程使用同一个锁。
同步方法弊端：
如果将一个大的方法声明为synchronized将会影响效率（多个线程需要判断锁，较为消耗资源）。

此时可以解决卖票问题

ublic class Ticket implements Runnable {
    private static int ticket = 100;

    public void run() {
        buyTicket();

    }

    public synchronized void buyTicket() {
        while (ticket > 0) {
            try {
                //模拟延时2s
                //Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "线程正在售卖第" + ticket-- + "张票");


        }
    }

    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        
        Thread thread = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        Thread thread3 = new Thread(ticket);
        Thread thread4 = new Thread(ticket);

        thread.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

4.2 同步代码块

语法：
synchnronized(Obj){}
1、Obj称之为 ==同步监视器==锁对象
	.对象如同锁，持有锁的线程可以在同步中进行。
	没有持有锁的线程，即使获取到了CPU的执行权，也进不去，因为没有获取锁。
	Obj可以是任何对象，但是强烈建议使用==共享资源==作为同步监视器。
	所谓共享资源也就是涉及到增删改的对象，查询的话无所谓。
	同步方法中无需指定同步监视器，因为同步方法中的同步监视器就是this,
	也就是这个对象本身，或者.class
2、同步监视器执行过程
	2.1 第一个线程访问，锁定同步监视器，执行业务逻辑
	2.2 第二个线程访问，发现同步监视器锁定，无法访问
	2.3 第一个线程执行完毕，解锁同步监视器，释放锁资源
	2.4 第二个线程访问，发现没有锁，抢到了锁资源，锁定并访问
	2.5

现在可以使用同步代码块解决刚才线程不安全的集合问题

public class UnsafeCollection {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
            	//锁住了所有线程共享的资源
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();

        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

同理同步代码块可以解决售票不安全问题

public class TicketRunnable implements Runnable {
    private int ticket = 100;
    Object object = new Object();

    @Override
    public void run() {

        while (true) {
            synchronized (object) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":正在售卖第" + ticket-- + ":票");
                }
            }
        }

    }

    public static void main(String[] args) {


        TicketRunnable ticketRunnable = new TicketRunnable();

        Thread thread = new Thread(ticketRunnable);
        Thread thread2 = new Thread(ticketRunnable);
        Thread thread3 = new Thread(ticketRunnable);
        Thread thread4 = new Thread(ticketRunnable);
        Thread thread5 = new Thread(ticketRunnable);

        thread.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
}

5 死锁
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，如某一个同步代码块拥有两个以上对象的锁时，就有可能发生死锁的问题。
5.1 死锁避免方式

产生死锁的四个必要条件
1、互斥条件：一个资源每次都只能被一个进程使用。
2、请求与保持条件：一个进程因请求资源而堵塞时,对已获得的资源保持不放。
3、不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
4、循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

所有说只要想办法破解其中任意一个或者多个条件，就可以避免死锁发生。

6 Lock锁

1、从JDK5.0开始,Java提供了更强大的线程同步机制--通过显示定义同步锁对象
来实现同步，同步锁使用Lock对象充当。
2、java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行
访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，
线程开始访问共享资源之前应先获得Lock对象。
3、ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性
和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,
可以显示加锁、释放锁。

/**
 * lock锁解决线程安全问题
 */
public class ReentrantLockTest implements Runnable {
    private ReentrantLock lock = new ReentrantLock();
    private int ticket = 1000;

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (ticket > 0) {
                    try {
                        //Thread.sleep(100);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    // while (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "：正在售卖" + ticket-- + "张票");
                    // }
                } else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        ReentrantLockTest reentrantLockTest = new ReentrantLockTest();

        Thread thread = new Thread(reentrantLockTest);
        Thread thread2 = new Thread(reentrantLockTest);
        Thread thread3 = new Thread(reentrantLockTest);
        Thread thread4 = new Thread(reentrantLockTest);

        thread.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }

7 synchronized与Lock的区别

1、Lock锁时显示锁(手动开启和关闭锁),synchronized是隐试的，
出了作用域会自动释放。
2、Lock只有代码块锁,synchronized有代码块锁和方法锁
3、使用Lock锁，Jvm将花费较少的时间来调度线程，性能更好，有更好的扩展性
（提供更多的子类）
4、有限使用步骤
Lock>同步代码块(已经进入了方法体,分配了相应资源)>同步方法（在方法体之外）

9 线程协作（生产者消费者模式）
9.1 线程通信
应用场景：生产者和消费者问题
假如仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。
如果仓库中放着产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。
在这里插入图片描述
9.2线程通信–分析

这是一个线程同步问题，生产者和消费者共享同一个资源,并且生产者和消费者之间
互相依赖，互为条件。
1、对于生产者，没有生产产品之前，要通知消费者等待，而生产者生产了产品之后，
有需要马上通知消费者消费。
2、对于消费者，在消费者之后，要通知生产者已经结束消费，需要生产新的产品
以供消费。
3、在生产者消费者问题中，仅仅有synchronized是不够的，
	3.1 synchronized 可阻止并发更新同一个共享资源,实现了同步。
	3.2 synchronized 不能用来实现不同线程之间的消息传递(通信)

9.3 == 线程通信方法==

java自带了几个方法来解决线程间的通信问题
1、wait() :  表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
2、wait(long timeout): 指定等待的毫秒数
3、notify():           唤醒一个处于等待状态的线程
3、notifyAll(): 唤醒同一个对象上所有调用wait()方法的线程，优先级别高的
				线程优先调度
他们都是父类Object的方法，所有都只能在同步方法或者同步代码块中使用，否则
会抛出IIIegalMonitorStateException

9.4 线程通信方式一管程法

并发协作模型“生产者/消费者” -->管程法
生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
消费者:负责处理数据的模块
缓冲区：消费者不能直接使用生产者的数据,他们之间有个缓冲区，
生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

在这里插入图片描述
生产者/消费者模型 —>管程法案例
10 线程池

为什么使用线程池？
原因:经常创建和销毁、使用量特别大的资源，如并发情况下的线程,对性能影响很大。
解决思路:提前创建好多个线程,放入线程池中,使用时直接获取，使用完放回池中。
可以
避免频繁创建销毁、实现重复利用。类似生活中的交通工具。
优点:
	1、提高响应速度(减少了创建新线程的时间)
	2、降低资源消耗(重复利用线程池中线程,不需要每次都创建)
	3、便于线程管理
		.corePoolSize:核心池的大小
		.maximumPoolSize:最大线程数
		.keepAliveTime:线程没有任务时最多保持多长时间后会终止

10.1 线程池使用
JDK5.0起提供了线程池相关API：ExcutorService和Executors
ExcutorService:真正的线程池接口,子类ThreadPoolExecutor

	void execute(Runnable command):执行任务/命令，没有返回值，
	一般用来执行Runnable
	<T>Futrue<T>submit(Callable<T>task):执行任务,有返回值,一般用来
	执行 Callable
	void shutdown():关闭连接池
	Executors:工具类、线程类的工厂类,用于创建并返回不同类型的线程池

10.1 线程池案例


public class ExecutorsTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new ThreadTest());
        executorService.execute(new ThreadTest());
        executorService.execute(new ThreadTest());
        executorService.execute(new ThreadTest());
        executorService.shutdown();
    }

}

class ThreadTest implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

听源哥的歌

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
浅谈多线程

进程？线程？多任务？电脑中运行着很多软件程序，如QQ、微信、浏览器、酷狗音乐、优酷视频等等，每个软件其实就是一个进程。而线程则是进程中的一个分支。一个进程中至少包括一个线程。线程可以理解为提高程序运行的效率，或者各司其职，如QQ中既可以同时打字聊天也可以语音，再比如高速路有三个车道，车辆就可以同时跑，充分利用道路，大大提高了通行效率。...
复制链接

扫一扫