多线程

最新推荐文章于 2021-08-24 15:51:05 发布

API工程师@

最新推荐文章于 2021-08-24 15:51:05 发布

阅读量296

点赞数

文章标签：多线程 java 并发编程

本文链接：https://blog.csdn.net/ghjgjhyfht/article/details/114914905

版权

多线程

一、线程简介

任务，进程，线程，多线程
进程是资源分配的基本单位，它是程序执行时的一个实例，在程序运行时创建；
线程是程序执行的最小单位，是进程的一个执行流，一个进程由多个线程组成的
多任务：一边吃饭一边玩手机、一边上厕所一边玩手机。大脑一个时间做一个事情。
多线程：为了提高效率，加了多个车道。
普通方法调用：只有主线程一条执行路径，执行完后在执行下一个。调用run();
多线程：多条执行路径，主线程和子线程并行交替执行。调用start();
进程：一次程序执行的过程。进程获得处理机而运行是通过调度而得到的。由程序、数据和进程控制块描述
程序和进程都可以在前后台运行
线程：就是独立的执行路径。
一个进程可以包括若个线程。线程是CPU调度和执行的单位。main():主线程的(用户线程)。gc():清理垃圾线程(JVM 守护线程)
线程的运行就是调度器安排调度的。
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
线程会带来额外的开销。
每个线程在自己的工作内存交互中，内存控制不当会造成数据的不一致

二、线程实现

Thread、Runnable、Callable

线程创建

继承Thread类（重点）:不建议使用：避免OOP单继承局限性。

OOP，Object Oriented Programming，原来就是面向对象的编程啊，还有OOD（面向对象的设计），OOA（面向对象的分析）

package com.xuchong.Thread;
//继承Thread类，重写run（）方法，调用start开启线程
public class TestThread extends Thread {
    public void run() {
        for(int i = 0; i < 10; ++i) {
            System.out.println("ok" + i);
        }

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

        for(int i = 0; i < 1000; ++i) {
            System.out.println("great" + i);
        }

    }
}

实例：下载器

package com.xuchong.Thread;

import com.sun.org.apache.bcel.internal.generic.NEW;
import org.apache.commons.io.FileUtils;

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

//练习Thread,实现多线程下载图片
public class TestThread1 extends Thread{
    private String url;
   private String name;
   public TestThread1(String url,String name){
       this.url=url;
       this.name=name;
   }
   //下载图片线程的执行体
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        try {
            webDownloader.downloader(url,name);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("ioe错误");
        }
        System.out.println("下载文件名为"+name);
    }

    public static void main(String[] args) {
        TestThread1 thread1 = new TestThread1("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1596690995872&di=7cdd263741a6ae5e597a179956383175&imgtype=0&src=http%3A%2F%2Fpic.baike.soso.com%2Fp%2F20140105%2F20140105142259-2002661733.jpg","89.jpg");
        TestThread1 thread3 = new TestThread1("http://mil.cnr.cn/jstp/201204/W020120422657327135550.jpg","78.jpg");
        TestThread1 thread2 = new TestThread1("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1596691190596&di=756c2e93386eb3a432717733cb044b9c&imgtype=0&src=http%3A%2F%2Fwww.hinews.cn%2Fpic%2F0%2F14%2F42%2F02%2F14420252_756025.jpg","19.jpg");
        thread1.start();
        thread2.start();
        thread3.start();
    }

}
//并不按照线程的顺序执行。
//下载器
class WebDownloader{
 //下载方法
 public void downloader(String url,String name) throws IOException {
     FileUtils.copyURLToFile(new URL(url),new File(name));
    }
}

实现Runnable接口（重点）：避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用

package com.xuchong.Runnable;

import com.xuchong.Thread.TestThread;

//创建线程方式2：实现Runnable接口，重写Run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestRunnable implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for(int i=0;i<10;i++){
            System.out.println("ok"+i);
        }
    }
    public static void main(String[] args) {
        //main线程，主线程
        //创建Runnable接口实现类对象
     TestRunnable testRunnable=new TestRunnable();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        //Thread thread = new Thread(testRunnable);
        //thread.start();
        new Thread(testRunnable).start();
        for(int i=0;i<1000;i++){
            System.out.println("great"+i);
        }
    }
}

实例：下网图

package com.xuchong.Runnable;

import com.xuchong.Thread.TestThread;
import com.xuchong.Thread.TestThread1;
import org.apache.commons.io.FileUtils;

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

public class TestRunnable1 implements Runnable{
    private String url;
    private String name;
    public TestRunnable1 (String url,String name){
        this.url=url;
        this.name=name;
    }
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        try {
            webDownloader.downloader(url,name);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("ioe错误");
        }
        System.out.println("下载文件名为"+name);
    }
    public static void main(String[] args) {
        TestRunnable1 thread1 = new TestRunnable1("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1596690995872&di=7cdd263741a6ae5e597a179956383175&imgtype=0&src=http%3A%2F%2Fpic.baike.soso.com%2Fp%2F20140105%2F20140105142259-2002661733.jpg","89.jpg");
        TestRunnable1 thread2 = new TestRunnable1("http://mil.cnr.cn/jstp/201204/W020120422657327135550.jpg","78.jpg");
        TestRunnable1 thread3 = new TestRunnable1("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1596691190596&di=756c2e93386eb3a432717733cb044b9c&imgtype=0&src=http%3A%2F%2Fwww.hinews.cn%2Fpic%2F0%2F14%2F42%2F02%2F14420252_756025.jpg","19.jpg");
        new Thread(thread1).start();
        new Thread(thread2).start();
        new Thread(thread3).start();
    }
}
//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String name) throws IOException {
        FileUtils.copyURLToFile(new URL(url),new File(name));
    }
}

火车票：

package com.xuchong.Runnable;
//多个线程同时操作同一个对象
//买火车票，问题：多个线程操作同一个对象会出现数据错乱 并发问题
public class TestRunnable2 implements Runnable{
    private int ticketNum=10;
    @Override
    public void run() {
        while (true){
            if(ticketNum<=0){
                break;
            }
            try {
                Thread.sleep(20);//模拟延时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNum--+"票");
        }
    }

    public static void main(String[] args) {
        TestRunnable2 ticket = new TestRunnable2();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"小红").start();
        new Thread(ticket,"黄牛").start();
    }
}

龟兔赛跑：

package com.xuchong.Runnable;
//模拟龟兔赛跑
public class Race implements Runnable{
    //胜利者
    private static String winner;
    @Override
    public void run() {
        for(int i=0;i<=100;i++){
            if(Thread.currentThread().getName().equals("兔子")&& i%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag=gameOver(i);
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"米");
        }
    }
    //判断是否完成比赛
    private boolean gameOver(int Step){
        //判断是否由胜利者
        if(winner!=null){
            return true;
        }else{if(Step>=100){
            winner=Thread.currentThread().getName();
            System.out.println("胜利者为"+winner);
            return true;
        }
        }
        return false;
    }

    public static void main(String[] args) {
        Race race=new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

实现Callable接口（了解）

package com.xuchong.Callable;


import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

//方式3：实现Callable接口
//优点：可以定义返回值，可以抛出异常
public class TestCallale implements Callable<Boolean> {
        private String url;
        private String name;
        public TestCallale(String url,String name){
            this.url=url;
            this.name=name;
        }
        //下载图片线程的执行体
        @Override
        public Boolean call() {
           WebDownloader webDownloader = new WebDownloader();
            try {
                webDownloader.downloader(url,name);
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("ioe错误");
            }
            System.out.println("下载文件名为"+name);
            return true;
        }

        public static void main(String[] args) throws ExecutionException, InterruptedException {
            TestCallale thread1 = new TestCallale("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1596690995872&di=7cdd263741a6ae5e597a179956383175&imgtype=0&src=http%3A%2F%2Fpic.baike.soso.com%2Fp%2F20140105%2F20140105142259-2002661733.jpg","89.jpg");
            TestCallale thread3 = new TestCallale("http://mil.cnr.cn/jstp/201204/W020120422657327135550.jpg","78.jpg");
            TestCallale thread2 = new TestCallale("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1596691190596&di=756c2e93386eb3a432717733cb044b9c&imgtype=0&src=http%3A%2F%2Fwww.hinews.cn%2Fpic%2F0%2F14%2F42%2F02%2F14420252_756025.jpg","19.jpg");
            //创建执行服务
            ExecutorService service = Executors.newFixedThreadPool(3);
            //提交执行
            Future<Boolean> result1=service.submit(thread1);
            Future<Boolean> result2=service.submit(thread2);
            Future<Boolean> result3=service.submit(thread3);
            //获取结果
            boolean r1=result1.get();
            boolean r2=result2.get();
            boolean r3=result3.get();
            //关闭服务
            service.shutdownNow();
        }

    }

    //下载器
    class WebDownloader{
        //下载方法
        public void downloader(String url,String name) throws IOException {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        }
    }

静态代理(StaticProxy)

静态代理模式：真实对象和代理对象都要实现同一个接口，代理对象代理真实角色
好处：代理对象可以做真实对象做不了的事，真实对象可以专注做自己的事

package com.xuchong.Static;
//静态代理模式：真实对象和代理对象都要实现同一个接口，代理对象代理真实角色
//好处：代理对象可以做真实对象做不了的事，真实对象可以专注做自己的事
public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}
//接口:Marry
interface Marry{
    //人间四大喜事
    void HappyMarry();
}
//真实角色
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("11111" );
    }
}
//代理角色:婚庆公司
class WeddingCompany implements Marry {
   //代理目标-->真实角色
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    private void after() {
        System.out.println("收尾款" );
    }

    private void before() {
        System.out.println("布置现场");
    }
}

Lamda表达式

简化：1、去除参数类型。2、简化括号。3、去掉大括号

package com.xuchong.lambda;
//lambda表达式只能由一行的表达式才可以去掉大括号
//前提是接口为函数式接口。即只有一个函数接口:只包含唯一一个抽象方法
//like=(参数)->{函数体};多个参数必须加括号
//like.Lambda();
public class TestLambda{
    //3、静态内部类
    static class Like implements Ilike{
        @Override
        public void Lambda() {
            System.out.println("I like Lambda2");
        }
    }
    public static void main(String[] args) {
        Like1 like1 = new Like1();
        like1.Lambda();
        Ilike like = new Like() ;
        like.Lambda();
        //4、局部内部类
        class Like3 implements Ilike{
            @Override
            public void Lambda() {
                System.out.println("I like Lambda3");
            }
        }

        Like3 like3 = new Like3() ;
        like3.Lambda();
        //5、匿名内部类,没有名字，必须借助接口或父类
        Ilike like4=new Ilike(){
            @Override
            public void Lambda() {
                System.out.println("I like Lambda4");
            }
        };
        like4.Lambda();
      //6、用Lambda简化 jdk8
       Ilike like5;
        like5=()->{System.out.println("I like Lambda5");};
        like5.Lambda();
    }
}
//1、定义一个函数式接口:只包含唯一一个抽象方法 隐式声明:就是抽象
interface Ilike{
    void Lambda();
}
//2、定义类
 class Like1 implements Ilike{
    @Override
    public void Lambda() {
        System.out.println("I like Lambda");
    }
}

三、线程状态

五大状态

线程停止Stop

setPriority:更改线程优先级。

package com.xuchong.Runnable;
//测试stop
//1、建议线程正常停止---->利用次数，不建议死循环
//2、建议使用标志位---->设置一个标志位
//3、不要使用stop或destroy等过时或者JDK不建议使用的方法
public class StopTest implements Runnable{
   //1、设置标志位
    private boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while(flag){
            System.out.println("run..."+i++);
        }
    }
    //2、设置一个公开的方法停止线程，转换标志位
public void stop(){
        this.flag=false;
}
    public static void main(String[] args) {
        StopTest stopTest = new StopTest();
        new Thread(stopTest).start();
        for (int i=0;i<1000;i++){
            System.out.println("main"+i);
            if(i==900){
                //调用stop方法切换标志位，让线程停止
                stopTest.stop();
                System.out.println("该线程停止");
            }
        }
    }
}

线程休眠Sleep

1、可以模仿网络延迟、倒计时

2、每个对象都有一把锁，sleep不会释放锁

模拟延时：放大问题的发生性

package com.xuchong.Runnable;
//放大问题的发生性
public class SleepTest implements Runnable{
    private int ticketNum=10;
    @Override
    public void run() {
        while (true){
            if(ticketNum<=0){
                break;
            }
            try {
                Thread.sleep(100);//模拟延时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNum--+"票");
        }
    }

    public static void main(String[] args) {
        SleepTest ticket = new SleepTest();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"小红").start();
        new Thread(ticket,"黄牛").start();
    }
}

倒计时：

package com.xuchong.Runnable;



import java.text.SimpleDateFormat;
import java.util.Date;


public class SleepTest2 {
    public static void main(String[] args) throws InterruptedException {
        //打印当前时间 new SimpleDateFormat("HH:mm:ss").format(time)
        Date time=new Date(System.currentTimeMillis());
        while(true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(time));
            time=new Date(System.currentTimeMillis());//更新时间
        }
    }
    //模拟倒计时
    public static void tenDown() throws InterruptedException {
        int num=10;
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0){
                break;
            }
        }
    }

}

线程礼让yield

1、让当前正在执行的线程暂停，但不阻塞

2、将线程从运行状态转变为就绪状态

3、礼让不一定成功！看CPU的心情

4、Sleep和yield都会暂时放弃CPU

package com.xuchong.Runnable;
//礼让不一定会成功
public class YieldTest {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"n").start();
    }
}
class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
    Thread.yield();
    System.out.println(Thread.currentThread().getName()+"线程结束执行");
    }
}
//Lambda表达式
package com.xuchong.Runnable;
//礼让不一定会成功
public class YieldTest {
    public static void main(String[] args) {
       Runnable myYield ;
       myYield=()->{
           System.out.println(Thread.currentThread().getName()+"线程开始执行");
           Thread.yield();
           System.out.println(Thread.currentThread().getName()+"线程结束执行");
       };
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();

    }

}

线程强行执行Join

1、Join合并线程，待此线程执行完毕后，在执行其他线程，其他线程阻塞

2、可以理解为插队

3、wait()会释放锁资源

4、底层调用wait() 会释放锁资源

package com.xuchong.Runnable;
//插队
public class JoinTest implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("VIP大驾光临"+i);
        }

    }

    public static void main(String[] args) throws InterruptedException {
        //启动线程
        JoinTest joinTest = new JoinTest();
        Thread thread = new Thread(joinTest);
        thread.start();
        //主线程
        for(int i=0;i<20;i++){
            if(i==10){
                thread.join();
            }
            System.out.println("肝帝"+i);
        }
    }
}

观测线程状态

package com.xuchong.Runnable;
//观察线程状态
public class LookTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }System.out.println("++++++");
        });
    //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);
    //观察启动
             thread.start();//启动
             state= thread.getState();//Run
        System.out.println(state);
        while (state!=Thread.State.TERMINATED){//只要线程不中止，就一直输出
            thread.sleep(1000);
            state=thread.getState();//更新状态
            System.out.println(state);
        }
    }
}

线程优先级（Priority)

线程优先级高的不一定先被调取。只是被先调用的概率就变大了，优先级较高的线程得到CPU资源较多。

package com.xuchong.Runnable;
//测试线程的优先级为1-10
public class PriorityTest {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        Runnable myPriority;
        myPriority=()->{
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        };
        Thread thread0=new Thread(myPriority);
        Thread thread1=new Thread(myPriority);
        Thread thread2=new Thread(myPriority);
        Thread thread3=new Thread(myPriority);
        Thread thread4=new Thread(myPriority);
        Thread thread5=new Thread(myPriority);
        //设置优先级
        thread0.start();
        thread1.setPriority(1);
        thread1.start();
        thread2.setPriority(4);
        thread2.start();
        thread3.setPriority(Thread.MAX_PRIORITY);//最大的为10
        thread3.start();
        thread4.setPriority(3);
        thread4.start();
        thread5.setPriority(9);
        thread5.start();
    }
}

上面结果明显性能倒置。

守护线程（Daemon）

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

package com.xuchong.Runnable;
//守护线程
//上帝守护你
public class TestDaemon {
    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();
        Thread thread1 = new Thread(you);
        thread1.start();
    }
}
//上帝
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("照亮世间，无限月读");
        }
    }
}
//你
class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("开心的一生");
        }huidaozhi
        System.out.println("----GOODBYE!WORLD------");
    }
}

抛InterruptedException（恢复中断异常）的代表方法有：
java.lang.Object 类的 wait 方法
java.lang.Thread 类的 sleep 方法
java.lang.Thread 类的 join 方法

四、线程同步

线程同步机制

并发：同一个对象被多个线程同时操作。抢票、取钱。

线程同步形成条件：队列和锁

线程同步synchronized：当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：

一个线程持有锁会导致其他所有需要此锁的线程挂起
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和延时调度，引起性能的问题；
如果优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。

三大不安全案例

每个线程在自己的工作内存交互中，内存控制不当会造成数据的不一致

买票：

package com.xuchong.syn;

import sun.security.krb5.internal.Ticket;

//不安全的买票
//同步
public class UnsafeByTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"鸣人").setPriority(Thread.MIN_PRIORITY);
        new Thread(buyTicket,"鸣人").start();
        new Thread(buyTicket,"马云").setPriority(Thread.MAX_PRIORITY);
        new Thread(buyTicket,"马云").start();
        new Thread(buyTicket,"斑").setPriority(5);
        new Thread(buyTicket,"斑").start();
    }
}
//买票类
class BuyTicket implements Runnable{
//票
    private int NumTicket=10;
    //设置标志位  外部停止方式
    boolean flag=true;
    @Override
    public void run() {
        //买票
        while(flag){
            try {
                buy();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
        //synchronized  同步方法，锁的是this
    public synchronized void buy() throws InterruptedException {
        //判断是否有票
        if(NumTicket<=0){
            flag=false;
            return;
        }
            //买票
            System.out.println(Thread.currentThread().getName()+"拿到第"+NumTicket--+"张票");
        }
    }

$\image-20210104130447397.png$

取钱：

package com.xuchong.syn;
//不安全的取钱
//两个人去取钱，同步
public class UnsafeBank {
    public static void main(String[] args) {
        Account account=new Account(1000,"结婚基金");
        Drawing you=new Drawing(account,50,"你");
        Drawing girlfriend=new Drawing(account,100,"女朋友");
        you.start();
        girlfriend.start();
    }

}
//账户,余额
class Account{
     int money;//余额
     String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行：模拟取款
class Drawing extends Thread {
    //账户
    Account account;
    //取款金额
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;

    }

    @Override
    public void run() {
        synchronized (account) {
            //取钱，先判断是否有钱
            if (account.money - drawingMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "卡内余额不足");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额=余额-取款金额
            account.money = account.money - drawingMoney;
            //手里的钱
            nowMoney = nowMoney + drawingMoney;
            System.out.println(this.getName() + "已取出" + nowMoney);
            System.out.println(account.name + "卡内余额为：" + account.money);

        }
    }
}

不安全的集合(List)

package com.xuchong.syn;

import java.util.ArrayList;
import java.util.List;
//不安全集合 同步
public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(
                    ()->{
                        synchronized (list){
                        list.add(Thread.currentThread().getName());}}
            ).start();
        }Thread.sleep(1000);

        System.out.println(list.size());
    }
}

同步方法以及同步块(synchronized)隐式定义

针对方法提出的机制

同步方法：public synchronized void method (int args){} 只有执行到返回值才会释放锁

缺陷：若将一个大的方法申明为synchronized将会影响效率

同步块：synchronized (Obj){}

为了使数据不被多个线程访问，java 提供了同步块以及同步方法两种实现，一旦一段代码被嵌入到一个synchronized关键字中，意味着放入了监视区域，JVM在后台会自动为这段代码实现锁的功能。

Obj称为同步监视器

Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class。

同步监视器的执行过程

第一个线程被访问，锁定同步监视器，执行其中的代码。
第二个线程访问，发现同步监视器被锁定，无法访问。
第一个线程访问结束，解锁同步监视器。
第二个线程访问，发现同步监视器没有锁，然后锁定并访问。

CopyOnWriterArrayList (juc里面的ArrayList)

package com.xuchong.syn;

import java.util.concurrent.CopyOnWriteArrayList;
//JUC安全集合
//自身安全，不需要synchronized修饰
public class juc {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList copyOnWriteArrayList = new CopyOnWriteArrayList();
        for (int i = 0; i < 10000; i++) {
            new Thread(
                    ()->{copyOnWriteArrayList.add(Thread.currentThread().getName());}).start();
        }
        System.out.println(copyOnWriteArrayList.size());
    }
}

volatile与synchronized的区别：

volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的,需要从主存中读取,synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住.
volatile仅能使用在变量级别,synchronized则可以使用在变量,方法.
volatile仅能实现变量的修改可见性,但不具备原子特性,而synchronized则可以保证变量的修改可见性和原子性.
volatile不会造成线程的阻塞,而synchronized可能会造成线程的阻塞.
volatile标记的变量不会被编译器优化,而synchronized标记的变量可以被编译器优化

死锁

相互等待对方的资源，某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

package com.xuchong.lock;

import sun.management.snmp.jvmmib.JVM_MANAGEMENT_MIBOidTable;

//死锁，多个线程互相抱着对方需要得资源，然后形成僵持
public class Deadlock {
    public static void main(String[] args) {
        Makeup g1=new Makeup(0,"落雁");
        Makeup g2=new Makeup(1,"沉鱼");
        g1.start();
        g2.start();
    }
}
//口红
class Lipstick{

}
//镜子
class Mirror{

}
//化妆
class  Makeup extends Thread {
    //需要的资源只有一份，用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    int choice;
    String girlName;

    public Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆，想要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {//获得口红得锁
                System.out.println(this.girlName + "获得口红");
            }
                Thread.sleep(1000);
                synchronized (mirror) {//一秒后获得镜子的锁
                    System.out.println(this.girlName + "获得镜子");
                }
            }
         else {
            synchronized (mirror) {//获得镜子得锁
                System.out.println(this.girlName + "获得镜子");
            }
                Thread.sleep(2000);
                synchronized (lipstick) {//一秒后获得口红的锁
                    System.out.println(this.girlName + "获得口红");
                }
            }
        }
    }

死锁产生的条件：

1、互斥条件：一个资源每次只能被一个进程使用

2、请求与保持：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

3、不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。

4、循环等待条件：若干进程形成一种头尾相接的循环等待资源关系。

若进程A和进程B在临界段上互斥，那么当进程A处于该临界段时，进程B可以打断进程A的运行。但是由于互斥机制，B是进不了临界区的。

Lock(锁)显示定义

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

package com.xuchong.end;

import java.util.concurrent.locks.ReentrantLock;

//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2=new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();

    }
}
class TestLock2 implements Runnable{
   int NumTicket=10;
   //定义Lock锁
    private final ReentrantLock reentrantLock=new ReentrantLock();
    @Override
    public void run() {
        while(true) {
            try {
                reentrantLock.lock();//那块变化加锁
                if (NumTicket > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(NumTicket--);
                } else {
                    break;
                }
            }finally {
                //解锁
                reentrantLock.unlock();
            }
        }
    }
}

区别：

Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费更少的时间来调度线程
使用顺序：Lock–>同步代码块–>同步方法。

五、线程通信问题

并发协作模型生产者/消费者模式

分析：这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间互相依赖，互为条件。

对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品后之后，有需要马上通知消费者消费
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
在生产者消费者问题中，仅有synchronized是不够的
synchronized可阻止并发更新同一个共享资源，实现了同步
synchronized不能用来实现不同线程之间的消息传递（通信）

wait():表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁

notify():唤醒一个处在等待状态的线程。

notiyAll：唤醒同一个对象上所有调用wait()方法的线程

解决方法1：管程法：生产者，消费者，缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区。

package com.xuchong.proandcoms;

//测试：生产者 ，消费者模型-->利用缓冲区解决：管城法
//生产者、消费者都需要缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer synContainer=new SynContainer();
        new Producer(synContainer).start();
        new Consumer(synContainer).start();
    }
}
//生产者
class Producer extends Thread{
    SynContainer synContainer;
    public Producer(SynContainer synContainer){
        this.synContainer=synContainer;
    }
    //生产

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                synContainer.push(new Chicken(i));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("生产了"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer synContainer;
    public Consumer(SynContainer synContainer){
        this.synContainer=synContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了-->"+synContainer.pop().id+"只鸡");
        }

    }
}
//商品
class Chicken{
    int id;//产品编号
    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer{
    //容器计数器
    int count=0;
    //容器大小
    Chicken chickens[]=new Chicken[10];
    //生产者放入商品
    public synchronized void push(Chicken chicken) throws InterruptedException {
        //判断容器满了，等待消费者消费
        if(count==chickens.length){
            //生产等待
            this.wait();
        }//如果没有满，我们需要丢入产品
        chickens[count]=chicken;
        count++;
        //通知消费者消费
        this.notify();
    }
    //消费者消费产品
    public synchronized Chicken pop() {
        //判断是否可以消费
        if (count==0){
            //等待生产者生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }//可以消费
        count--;
        Chicken chicken=chickens[count];
        //通知生产者生产
        this.notify();
        return chicken;
            }
        };

解决方法2：信号灯法

package com.xuchong.proandcoms;
//测试生产者消费者的方法：信号灯发
public class TestPC2 {
    public static void main(String[] args) {
        Movie movie=new Movie();
        new Player(movie).start();
        new Watcher(movie).start();
    }
}
//生产者-->演员
class Player extends Thread{
    Movie movie;
    public Player(Movie movie){
        this.movie=movie;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%10==0){
                this.movie.play("广告"+i);
            }else{
                this.movie.play("火影忍者"+i);
            }

        }
    }
}
//消费者-->观众
class Watcher extends Thread{
    Movie movie;
    public Watcher(Movie movie){
        this.movie=movie;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            this.movie.watch();
        }
    }
}
//产品-->电影
class Movie {
    //演员排练，观众等待
    //观众观看，演员排练
    String video;//节目
    boolean flag=true;
    //排练
    public synchronized void play(String video){
        if(!flag){
            this.watch();
        }
        System.out.println("演员排练"+video);
        //通知观众观看
        this.notify();
        this.video=video;
        this.flag=false;

    }
    //观看
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了"+video);
        //通知演员表演
        this.notify();
        this.flag=false;
    }
}

使用线程池

JDK5.0之后提供了线程池相关API：ExexutiorService和Executors
ExexutiorService:真正的线程池接口。常见子类ThreadPoolExecutor
void execute(Runnable command):执行命令/任务，没有返回值，一般执行Runnable
Futuresubmit(Callable task):执行任务，有返回值，一般用来执行Callable
void shutdown():关闭连接池
Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池

package com.xuchong.Pool;

import java.util.Collection;
import java.util.List;
import java.util.concurrent.*;

public class TestPool {
    public static void main(String[] args) {
        //创建服务。创建线程
        // 1、Executors.newFixedThreadPool 参数：线程池的大小
        ExecutorService executorService=Executors.newFixedThreadPool(10);
        executorService.execute( new MyThread());
        executorService.execute( new MyThread());
        executorService.execute( new MyThread());
        //2、关闭链接
        executorService.shutdown();
    }

}
class MyThread implements Runnable{

    @Override
    public void run() {

            System.out.println(Thread.currentThread().getName());

    }
}

虚拟空间管理抖动：

页面置换时用于换页的时间远多于程序运行时间
原因：页面淘汰算法不合理；分配给进程的物理页面数(驻留集)太少。
策略：局部置换策略；为缺页率高的增加有限物理块；选择暂停一些进程。

API工程师@

关注

0
点赞
踩
0

收藏

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

多线程一、线程简介任务，进程，线程，多线程进程是资源分配的基本单位，它是程序执行时的一个实例，在程序运行时创建；线程是程序执行的最小单位，是进程的一个执行流，一个进程由多个线程组成的多任务：一边吃饭一边玩手机、一边上厕所一边玩手机。大脑一个时间做一个事情。多线程：为了提高效率，加了多个车道。普通方法调用：只有主线程一条执行路径，执行完后在执行下一个。调用run();多线程：多条执行路径，主线程和子线程并行交替执行。调用start();进程：一次程序执行的过程。进程获得处理机而运行是通过调
复制链接

扫一扫