多线程基础

多线程

  • 多任务、多线程
  • 程序、进程、线程
  • 学着看jdk文档
  • 线程的创建
    • 1.继承Thread类
    • 2.实现Runable接口
    • 理解并发的场景
    • 龟兔赛跑场景
    • 实现callable接口
  • 理解函数式接口
  • 理解线程的状态
    • 线程停止
    • 线程休眠sleep
      • 1.网路延迟
      • 2.倒计时等
    • 线程礼让yield
    • 线程强制执行
  • 观察线程状态
  • 线程的优先级
  • 守护线程
  • 线程同步机制
    • 1.synchronized 同步方法
    • 2.同步块synchronized(Obj){}
  • lock
  • synchronized与lock

多任务、多线程

在多任务场景下,两件事看上去同时在做,但实际上,你的大脑在同一时间只做一件事,间隔时间可能很少,但这似乎让你感觉这两件事是同时在做

考虑阻塞问题,引入多线程的场景,多线程并发场景

多线程基础_第1张图片

程序、进程、线程

程序=指令+数据(静态的)
在操作系统中运行的程序就是进程,一个进程可以有多个线程
比如,看视频时听声音,看图像,看弹幕等

学着看jdk文档

比如你要看Thread
你可以搜索,然后阅读
多线程基础_第2张图片
往下翻你会看到:
多线程基础_第3张图片
多线程基础_第4张图片
多线程基础_第5张图片

线程的创建

1.继承Thread类

//创建线程方式一:继承Thread类,重写run方法,调用start()方法开启线程
public class TestThread1  extends Thread{
     

    @Override
    public void run() {
     
        //run()方法线程体
        IntStream.range(0,20).forEach(i->{
     
            System.out.println("我在看代码"+i);
        });
    }

    public static void main(String[] args) {
     
        //创建一个线程对象
        TestThread1 testThread1=new TestThread1();
        //调用start()方法,启动线程,不一定立即执行,由cpu调度执行
        testThread1.start();

        //主方法 main方法
        IntStream.range(0,20).forEach(i->{
     
            System.out.println("我在学习多线程"+i);
        });
    }
}

一个小练习:

//练习thread实现对线程同步下载图片
public class TestThread2 extends Thread{
     

    private String url;
    private String name;

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

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

    public static void main(String[] args) {
     
        TestThread2 t1=new TestThread2("https://profile.csdnimg.cn/B/D/2/3_sxh06","1.jpg");
        TestThread2 t2=new TestThread2("https://profile.csdnimg.cn/B/D/2/3_sxh06","2.jpg");
        TestThread2 t3=new TestThread2("https://profile.csdnimg.cn/B/D/2/3_sxh06","3.jpg");

        t1.start();
        t2.start();
        t3.start();

    }
}

//下载器
class WebDownload{
     
    //下载方法
    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异常,downloader方法出错");
        }
    }
}

2.实现Runable接口

//创建线程的方法2:实现Runable接口
public class TestThread3 implements Runnable{
     

    @Override
    public void run() {
     
        //run()方法线程体
        IntStream.range(0,20).forEach(i->{
     
            System.out.println("我在看代码"+i);
        });
    }

    public static void main(String[] args) {
     
        //创建一个线程对象
        TestThread3 testThread3=new TestThread3();
        //调用start()方法,启动线程,不一定立即执行,由cpu调度执行
//        Thread thread=new Thread(testThread3);
//        thread.start();

        //或者这样简写
       new Thread(testThread3).start();
        //主方法 main方法
        IntStream.range(0,100).forEach(i->{
     
            System.out.println("我在学习多线程"+i);
        });
    }
}

多线程基础_第6张图片

理解并发的场景

当多个线程使用同一个资源时,会出现问题,看看下面这个买火车票的例子:

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 ticket=new TestThread4();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"张三").start();
        new Thread(ticket,"李四").start();
    }
}

看看运行的结果:
多线程基础_第7张图片
可以看到案例中的线程不安全问题,同时数据也是不正确的

龟兔赛跑场景

/**
 * 模拟龟兔赛跑
 */
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 steps){
     
        //判断是否有胜利者
        if (winner !=null){
     
            //已经存在胜利者
            return true;
        }else if (steps >= 100){
     
            winner=Thread.currentThread().getName();
            System.out.println("胜利者是:"+winner);
            return true;
        }else{
     
            return false;
        }
    }

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

实现callable接口

//线程创建方式3
public class TestCallable implements Callable<Boolean> {
     
    private String url;
    private String name;

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

    @Override
    public Boolean call() {
     
        com.sxh.thread.WebDownload webDownload=new com.sxh.thread.WebDownload();
        webDownload.downloader(url,name);
        System.out.println("下载了文件名:"+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
        TestCallable t1=new TestCallable("https://profile.csdnimg.cn/B/D/2/3_sxh06","1.jpg");
        TestCallable t2=new TestCallable("https://profile.csdnimg.cn/B/D/2/3_sxh06","2.jpg");
        TestCallable t3=new TestCallable("https://profile.csdnimg.cn/B/D/2/3_sxh06","3.jpg");

        //创建执行服务
        ExecutorService ser= Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1=ser.submit(t1);
        Future<Boolean> r2=ser.submit(t2);
        Future<Boolean> r3=ser.submit(t3);
        //获取结果
        boolean rs1=r1.get();
        boolean rs2=r2.get();
        boolean rs3=r3.get();
        //关闭服务
        ser.shutdownNow();
    }

}

理解函数式接口

任何接口,只包含唯一一个抽象方法,就是函数式接口

/**
 * lambdab表达式的发展
 */
public class TestLambda1 {
     
    //3.静态内部类
    static class Like2 implements ILike{
     
        @Override
        public void lambda() {
     
            System.out.println("i like lambda2");
        }
    }

    public static void main(String[] args) {
     
        ILike like=new Like();
        like.lambda();

        like=new Like2();
        like.lambda();

        //4.局部内部类
       class Like3 implements ILike{
     
            @Override
            public void lambda() {
     
                System.out.println("i like lambda3");
            }
        }
        like=new Like3();
        like.lambda();

        //5.匿名内部类
        like=new ILike() {
     
            @Override
            public void lambda() {
     
                System.out.println("i like lambda4");
            }
        };
        like.lambda();

        //6.用lambda简化
        like=()->{
     
            System.out.println("i like lambda5");
        };
        like.lambda();
    }
}

//1.定义一个函数式接口
interface ILike{
     
    void lambda();
}

//2.实现类
class Like implements ILike{
     

    @Override
    public void lambda() {
     
        System.out.println("i like lambda");
    }
}

理解线程的状态

多线程基础_第8张图片

线程停止

public class TestStop implements Runnable{
     

    //1.设置一个标志位
    private boolean flag=true;
    @Override
    public void run() {
     
       int i=0;
       while (flag){
     
           System.out.println("run...thread.."+i++);
       }
    }

    //2.设置一个公开的方法停止线程,转换标志位
    public void stop(){
     
           this.flag=false;
    }


    public static void main(String[] args) {
     
        TestStop stop=new TestStop();
        new Thread(stop).start();


        for (int i = 0; i < 1000; i++) {
     
            System.out.println("main"+i);
            if (i==900){
     
                //调用stop方法,让线程停止
                stop.stop();
                System.out.println("线程该停止了");
            }
        }
//        IntStream.range(0,1000).forEach(i->{
     
//            
//        });
    }
}

线程休眠sleep

每个对象都有一把锁,sleep不会释放锁

1.网路延迟

            //模拟延迟
            try {
     
                Thread.sleep(200); //ms
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }

2.倒计时等

 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;
            }
        }
    }
 public static void main(String[] args) {
     
        //打印系统当前时间
        Date startTime=new Date(System.currentTimeMillis());
        while (true){
     
            try {
     
                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重新调度
public class TestYield {
     
    public static void main(String[] args) {
     
        MyYield myYield=new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
class MyYield implements  Runnable{
     

    @Override
    public void run() {
     
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

线程强制执行

//测试join方法  想象为插队
public class TestJoin implements  Runnable{
     
    @Override
    public void run() {
     
        for (int i = 0; i < 100; i++) {
     
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
     
        //启动线程
        TestJoin testJoin=new TestJoin();
        Thread thread=new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 1000; i++) {
     
            if (i==200){
     
                thread.join(); //插队
            }
            System.out.println("main"+i);
        }
    }
}

观察线程状态

public class TestState {
     
    public static void main(String[] args) throws InterruptedException {
     
        Thread thread=new Thread(()->{
     
            for (int i = 0; i < 5; i++) {
     
                try {
     
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }
            System.out.println("//");
        });

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

        //启动后
        thread.start();
        state=thread.getState();
        System.out.println(state);   //Run

        while (state != Thread.State.TERMINATED)
        {
     
            Thread.sleep(100);
            state=thread.getState();//更新线程状态
            System.out.println(state);   //Run
        }
    }
}

线程的优先级

//测试线程的优先级
public class TestPriority {
     
    public static void main(String[] args) {
     
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());

        MyPriority myPriority=new MyPriority();

        Thread t1=new Thread(myPriority);
        Thread t2=new Thread(myPriority);
        Thread t3=new Thread(myPriority);
        Thread t4=new Thread(myPriority);
        Thread t5=new Thread(myPriority);
        Thread t6=new Thread(myPriority);
        //先设置优先级,在启动
        t1.start();
        t2.setPriority(1);
        t2.start();
        t3.setPriority(4);
        t3.start();
        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();
        t5.setPriority(-1);
        t5.start();
        t6.setPriority(11);
        t6.start();

    }
}
class MyPriority implements Runnable{
     

    @Override
    public void run() {
     
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
    }
}

守护线程

线程分为用户线程守护线程

//测试守护线程
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();

        new Thread(you).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 < 36000; i++) {
     
            System.out.println("你活着"+i);
        }
        System.out.println("goodbye!!");
    }
}

线程同步机制

解决安全性问题:队列+锁

1.synchronized 同步方法

默认锁的是this,如需锁其他的,使用下面的同步块

//synchronized 同步方法
    private  synchronized void buy(){
     
        if (ticketNums<=0){
     
            flag=false;
            return;
        }
        //模拟延迟
        try {
     
            Thread.sleep(100);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        //买票
        System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"张票");
    }

2.同步块synchronized(Obj){}

锁的对象是变化的量,需要增删改的对象
obj称之为同步监视器,即监视对象

public class UnsafeList {
     
    public static void main(String[] args) {
     
        List<String> list=new ArrayList<String>();
        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());
    }
}

lock

class A{
     
     //ReentrantLock 可重入锁
     private final ReentrantLock lock=new ReentrantLock();
     public void f(){
     
       lock.lock();//加锁
       try{
     
           //.....
        }
       finally{
     
          lock.unlock();//释放锁
        }
     }
   
}


synchronized与lock

  1. lock是显示锁需要手动开关,synchronized是隐式锁,出了作用域自动释放
  2. lock只有代码块锁,synchronized有代码块锁和方法锁
  3. JVM将花费更少的时间来调度线程,性能更好,更有扩展性
  4. 优先使用:Lock>同步代码块>同步方法

你可能感兴趣的:(笔记,JavaEE,java)