首页 > 编程语言 > 详细

多线程的学习

时间:2021-03-13 11:55:26      阅读:32      评论:0      收藏:0      [点我收藏+]

多线程

线程简介

程序:程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。

进程(Process):在操作系统中运行的程序就是进程,是一个动态的概念,是系统资源分配的单位。

线程(Thread):通常一个进程中可以包含若干个线程,线程是CPU调度和执行的单位,独立执行的路径。

多线程:真正的多线程是具有多个CPU的、即多核、如服务器;模拟出来的多线程只有一个CPU,因为切换的很快,所有就有同时执行的错觉。

 

线程核心:

技术分享图片

 

线程的三种创建方式:

  • 继承Thread类

    1. 自定义线程类继承Thread类

    2. 重写run()方法,编写线程执行体

    3. 创建线程对象,调用start()方法启动线程

    对于run()方法和start()方法:

    技术分享图片

    run()方法是规规矩矩的,run()来了就先走完run()方法再继续主线程,而start()方法则start()来了就调用run()方法,并且主线程和子线程并行交替执行

    一般而言,我们都是调用start()方法,而不是调用run()方法

     

    用多线程下载图片的例子

    package com.ge.demo01;
    ?
    ?
    import org.apache.commons.io.FileUtils;
    ?
    import java.io.File;
    import java.io.IOException;
    import java.net.URL;
    ?
    //练习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() {
           WebDownloader webDownloader = new WebDownloader();
           webDownloader.downloader(url,name);
           System.out.println("下载了文件名为:"+name);
      }
    ?
       public static void main(String[] args) {
           TestThread2 t1 = new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa3.att.hudong.com%2F35%2F34%2F19300001295750130986345801104.jpg&refer=http%3A%2F%2Fa3.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1618031636&t=5ed56a3daeaa5339720c17d4b61a414b","1.jpg");
           TestThread2 t2 = new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa0.att.hudong.com%2F30%2F29%2F01300000201438121627296084016.jpg&refer=http%3A%2F%2Fa0.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1618031396&t=b0ec2ebc0ee5c0faefb374a213a091bc","2.jpg");
           TestThread2 t3 = new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa0.att.hudong.com%2F52%2F62%2F31300542679117141195629117826.jpg&refer=http%3A%2F%2Fa0.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1618031769&t=cba6b77e67dc2aedacf5f8bbfabe2dfd","3.jpg");
    ?
           t1.start();
           t2.start();
           t3.start();
    ?
      }
    }
    ?
    ?
    //下载器
    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异常,downloader方法出现问题");
          }
      }
    }
    ?

     

     

  • 实现Runnable接口

    1. 定义MyRunnable类实现Runnable接口

    2. 实现run()方法,编写线程执行体

    3. 创建线程对象,调用start()方法启动线程

      代码实例

      package com.ge.demo01;
      ?
      //创建线程方式2:实现runnable接口,重写run方法,执行线程需要丢入runnable接口的实现类,调用start方法
      public class TestThread3 implements Runnable{
      ?
         @Override
         public void run() {
             for (int i = 0; i < 20; i++) {
                 System.out.println("我是线程大大大大大大任务:"+i);
            }
        }
      ?
         public static void main(String[] args) {
      ?
             //创建Runnable接口的实现类TestThread3
             TestThread3 testThread3 = new TestThread3();
      ?
             //创建一个Thread实例,同时传入testThread3
             Thread thread = new Thread(testThread3);
      ?
             //调用thread对象中的start方法,叫做代理
             thread.start();
      ?
             for (int i = 0; i < 1000; i++) {
                 System.out.println("我在学习多线程:"+i);
            }
      ?
        }
      ?
      }
      ?

 

对比前面两种方法,建议使用实现Runnable这种方法,因为其避免了OOP单继承的局限性,灵活方便,方便同一个对象被多个线程使用

 

小作业,龟兔赛跑

package com.ge.demo01;
?
public class Race implements Runnable{
?
?
   //胜利者
   private static String winner;
?
   //判断比赛是否结束
   boolean gameOver = false;
?
   @Override
   public void run() {
       for (int i = 1; i <= 100&&gameOver==false; i++) {
           if(Thread.currentThread().getName().equals("乌龟")){
               try {
                   Thread.sleep(2);
              } catch (InterruptedException e) {
                   e.printStackTrace();
              }
          }
           System.out.println(Thread.currentThread().getName() + "跑了第" + i + "步");
           if(i==100&&gameOver==false){
               winner = Thread.currentThread().getName();
               gameOver=true;
               System.out.println(Thread.currentThread().getName()+"赢得了比赛");
          }
      }
  }
?
   public static void main(String[] args) {
       Race race = new Race();
       new Thread(race,"兔子").start();
       new Thread(race,"乌龟").start();
  }
}
?

 

  • 实现Callable接口

    1. 实现Callable接口,需要返回值类型

    2. 重写call方法,需要抛出异常

    3. 创建目标对象

    4. 创建服务—>关闭服务

    Callable好处:

  • 可以定义返回值

  • 可以抛出异常

 

静态代理

静态代理模式:

- 真实对象和代理对象都要实现同一个接口
- 代理对象要代理真实角色

 

好处:代理对象可以做很多真实对象做不了的事情

真实对象专注做自己的事情

 

代码如下

package com.ge.Demo01;
?
public class StaticProxy {
   public static void main(String[] args) {
       MarryCompany marryCompany = new MarryCompany(new Person());
       marryCompany.happyMarry();
  }
?
}
?
interface Marry{
   //结婚这件事的编码
   void happyMarry();
}
?
//真实对象,结婚的人
class Person implements Marry{
   @Override
   public void happyMarry() {
       System.out.println("结婚啦!");
  }
}
?
//代理对象,婚庆公司
class MarryCompany implements Marry{
?
   //代理谁—>真实目标角色
   private  Marry target;
?
   public MarryCompany(Marry target) {
       this.target = target;
  }
?
   @Override
   public void happyMarry() {
       after();
       this.target.happyMarry();//这就是真实对象
       later();
  }
?
   private void later() {
       System.out.println("结婚后,收拾");
  }
?
   private void after() {
       System.out.println("结婚前,布置场景");
  }
}

类比多线程的思想可知:

Thread就好比婚庆公司,它们分别代理了Runnable和happyMarry()。

 

Lamda表达式(λ)

意义:避免匿名内部类定义过多,用简单的代码代替复杂的内容,其实质属于函数式编程的概念。

首先,了解函数式接口:

  • Functional Interface(函数式接口)是学习Java8 lambda表达式的关键所在

  • 任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。

  • 对于函数式接口,我们可以通过lambda表达式来创建该接口的对象

 

类型展示:

love = a->System.out.println("i love you-->"+a);

 

总结:

  • lambda表达式只能有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹

  • 前提是接口为函数式接口

  • 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上括号

 

线程状态

技术分享图片

  • 线程停止

    //1. 建议线程正常停止———>利用次数,不建议死循环
    //2. 建议使用标志位————>设置一个标志位
    //3. 不要使用stop或者destroy等过时或者JDK不建议使用的方法

 

  • 线程休眠(sleep)

    package com.ge.state;
    ?
    import java.text.SimpleDateFormat;
    import java.util.Date;
    ?
    ?
    public class TestSleep2 {
       //模拟倒计时
       static public void tenDown() throws InterruptedException {
           int num = 10;
           while(true){
               Thread.sleep(1000);
               System.out.println("倒计时:"+num--);
               if(num<0){
                   break;
              }
          }
      }
       
       //持续打印系统时间
       static public void printDate(){
           Date startDate = new Date(System.currentTimeMillis());
    ?
           while(true){
               try {
                   Thread.sleep(1000);
                   System.out.println(new SimpleDateFormat("HH:mm:ss").format(startDate));
                   startDate = new Date(System.currentTimeMillis());
              } catch (InterruptedException e) {
                   e.printStackTrace();
              }
          }
      }
    ?
       public static void main(String[] args) throws InterruptedException {
           tenDown();
           printDate();
      }
    }
    ?

 

  • 线程礼让

    • 让当前正在执行的线程暂停,但不阻塞

    • 将线程从运行状态转为就绪状态

    • 让cpu重新调度,礼让不一定成功!看CPU心情……

    package com.ge.state;
    
    
    //测试礼让线程
    //礼让不一定成功,看CPU心情
    public class TestYield implements Runnable{
    
        public static void main(String[] args) {
    
            new Thread(new TestYield(),"A").start();
            new Thread(new TestYield(),"B").start();
    
        }
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"线程开始执行");
            Thread.yield();
            System.out.println(Thread.currentThread().getName()+"线程停止");
        }
    }
    
    
    

 

  • Join

    • Join合并线程,待此线程执行完成后,再执行其它线程,其它线程阻塞

    • 可以想象成插队

      package com.ge.state;
      
      //测试join方法
      //想象为插队
      public class TestJoin implements Runnable{
      
          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++) {
                  System.out.println("main方法在路上"+i);
                  if(i==200){
                      thread.join();
                  }
              }
          }
      
      
          @Override
          public void run() {
              for (int i = 0; i < 1000; i++) {
                  System.out.println("vip来了"+i);
              }
          }
      }
      

 

  • 线程几个状态的观测代码

package com.ge.state;


//观察测试线程的状态
public class TestState {

    public static void main(String[] args) throws InterruptedException {
        //建立线程——>睡眠五次,每次一秒,用lambda方法
        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);

        //观察启动后
        thread.start();
        //再获取一次状态
        state = thread.getState();
        System.out.println(state);


        //只要线程不终止,就一直获取观察
        while (state!=Thread.State.TERMINATED){
            Thread.sleep(100);
            state = thread.getState();
            System.out.println(state);
        }
    }
}

 

  • 线程的优先级

    • 线程的优先级用数字表示,范围从1~10,数字越大优先级越大

    • 优先级只是一种概率问题,优先级高(比如10)并不是说这个线程就一定是最先执行的,只是优先执行的概率高一些而已,这都是看CPU的调度的

    • 每个线程刚创建时,优先级默认为5

示例代码:

package com.ge.state;

//测试线程的优先级
public class TestPriority {

    //一个main方法用于测试
    public static void main(String[] args) {

        //打印主线程的默认优先级
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());

        MyPrority myPrority = new MyPrority();
        Thread t1 = new Thread(myPrority);
        Thread t2 = new Thread(myPrority);
        Thread t3 = new Thread(myPrority);
        Thread t4 = new Thread(myPrority);
        Thread t5 = new Thread(myPrority);
        Thread t6 = new Thread(myPrority);

        //先设置优先级,然后再启动
        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();
    }

}

//一个实现Runnable接口的类
class MyPrority implements  Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
    }
}

 

  • 守护(daemon)线程

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

    • 虚拟机必须确保用户线程执行完毕

    • 虚拟机不用等待守护线程执行完毕

    • 守护线程如:后台记录操作日之,监控内存,垃圾回收等

 

package com.ge.state;

public class TestDeamon {

    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认为false,设置为true后变成了守护线程
        thread.start();//上帝守护线程启动

        new Thread(new 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 = 1; i <= 36500; i++) {
            System.out.println("你活了:"+i+"天");
        }
        System.out.println("离开这个美丽的世界");
    }
}

 

  • 线程同步

    • 并发:同一个对象被多个线程同时操作(1万个人抢一张票)

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

    • 队列和锁(每个对象都拥有一把锁):synchronized

    线程不安全例子(原因是每个线程用各自的内存):

    1. 银行取钱

    2. 抢票机制

    3. List,代码如下:

package com.ge.syn;

import java.util.ArrayList;
import java.util.List;

//线程不安全的集合List<>
//原因是多条线程有可能同一时间插入到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(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

 

如何解决线程不安全的问题?

使用synchronized方法和synchronized块

  • synchronized方法控制对“对象"的访问,每个对象对应一把锁,

  • 缺陷,若将一个大的方法申明为synchronized将会影响效率,方法里面需要修改的内容才需要加锁,锁的太多,浪费资源

 

下面是实例一,采用的是synchronized块

package com.ge.syn;

//不安全的取钱
//两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        //设置账户
        Account account = new Account(1000, "Marry");
        //两个线程
        Drawing me = new Drawing(account, 50, "me");
        Drawing girlfriend = new Drawing(account, 100, "girlfriend");

        me.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{
    //你打算取多少钱
    int drawingMoney;
    //你口袋剩余的钱
    int nowMoney;
    //你的账户
    Account account;
    //构造方法
    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account=account;
        this.drawingMoney=drawingMoney;

    }

    //取钱的过程,重写run方法
    @Override
    public void run() {

        //锁的对象就是变化的量
        synchronized (account){if(drawingMoney>account.money){
            System.out.println(Thread.currentThread().getName()+"余额不足!");
            return;
        }

            //sleep可以放大问题的发生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //成功取钱,账户余额减少
            account.money=account.money-drawingMoney;
            //口袋里的钱增加
            nowMoney = nowMoney + drawingMoney;

            //打印你的账户余额
            System.out.println(account.name+"余额为:"+account.money);
            //打印你口袋里的钱(this.getName()=Thread.currentThread().getName())
            System.out.println(this.getName()+"口袋里的钱"+nowMoney);
        }
        }
}

 

注意:Thread.sleep这个方法加进去是很有必要的,有时候主线程(main)都跑完了,其它线程还没跑完,会导致打印的结果不是预料中的(即使提前加了锁)

 

死锁:

两个或者多个线程都在等待对方释放资源,都停止执行的情形

化妆品的例子:

package com.ge.thread;


//死锁
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0, "灰姑娘");
        Makeup g2 = new Makeup(1, "白雪公主");
        new Thread(g1).start();
        new Thread(g2).start();
    }
}

//口红
class Lipstick{

}

//镜子
class Mirror{

}

//产生死锁的类
class Makeup implements Runnable{

    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String grilName;//使用化妆品的人

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

    @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.grilName+"获得口红的锁");
                Thread.sleep(1000);

            }synchronized (mirror){//一秒钟后想获得镜子
                System.out.println(this.grilName+"一秒钟后获得镜子的锁");
            }
        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.grilName+"获得口红的锁");
                Thread.sleep(1000);

            }synchronized (lipstick){//一秒钟后想获得口红
                System.out.println(this.grilName+"一秒钟后获得镜子的锁");
            }
        }
    }
}

 

产生死锁的四个必要条件:

  1. 互斥:一个资源每次只能被一个进程使用

  2. 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放

  3. 不剥夺资源:进程以获得的资源,在未使用完之前,不能强行剥夺

  4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系

对于上面的必要条件,我们只要破解其中一个就能避免死锁发生

 

 

 

多线程的学习

原文:https://www.cnblogs.com/PinkBird/p/14527611.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!