Java之多线程

知识点
  • 进程：正在运行的某个程序 如：QQ 浏览器
    系统会为这个进程分配独立的内存资源
  • 线程：具体执行任务的最小单位
    一个进程最少拥有一个线程(主线程 运行起来就执行的线程)
    线程之间是共享一片内存空间(进程申请)
    线程之间可以通信 (数据传递：多数为主线程和子线程)
    每一个线程都有自己的运行回路(生命周期)
  • 线程的生命周期 状态
    New：新建 线程刚被创建
    RUNNABLE：就绪状态(准备好了，随时可以运行)只要抢到时间片就可以运行
    BLOCKED：阻塞状态 (时间片结束 sleep wait)
    WAITING：等待 wait
    TIMED_WAITING
    TERMINATED
  • 为什么需要创建一个子线程
    如果在主线程中存在比较耗时的操作 如：下载视频，上传文件，数据处理
    这些操作会阻塞主线程，后面的任务必须等这些任务执行完毕，之后才能执行，用户体验比较差
    为了不阻塞主线程，需要将耗时的任务放在子线程中去处理

  • 线程阻塞的原理


    2M``N0O_9774F1D0TJ)Z@X6.png
内容梗概

-1. 如何创建一个(子)线程
-2.线程的同步
-3.主线程和子线程之间使用数据回调
-4.两个线程交替执行
-5.线程间的通信

主要内容
-1.如何创建一个(子)线程
  • 写一个类继承于Thread,实现run方法
  public class MyClass{
      static TestThread1 tt2;
      public static void main(String[] args){
          // 创建Thread的对象
        TestThread1 tt=new TestThread1();
        // 设置线程的名称
       tt.setName("子线程1");
       // 开启任务
       tt.start();
       }
  }
  class TestThread1 extends Thread{
  //实现run方法

  @Override
  public void run() {
    //run方法里就是具体需要执行的代码
    String name=Thread.currentThread().getName();
    for (int i = 1; i <= 100; i++) {
        System.out.println(name+":"+i);
    }
    super.run();
    }
  }

注：不能同时开启同一个线程，会出错

  TestThread1 tt=new TestThread1();
  tt.setName("子线程1");
  tt.start();
  TestThread1 tt2;
  tt2=new TestThread1();
  tt2.setName("子线程2");
  tt2.start();
  • 实现Runnable接口,实现run方法
    (1)创建任务：创建类实现Runnable接口
    (2)使用Thread,为这个任务分配线程
    (3)开启任务,start()

有四种使用方法，先创建一个类

  class ZRThread implements Runnable{
  @Override
  public void run() {
      for (int i = 1;  i< 100; i++) {
          System.out.println(Thread.currentThread().getName()+": "+i);
      }
    }
  }

第一种方法：

    //步骤1：创建一个任务：创建一个类实现Runnable接口
    ZRThread zt=new ZRThread();
    //步骤2：使用Thread操作这个任务
    Thread t=new Thread(zt);
    t.setName("子线程1");
    t.start();
    Thread t2=new Thread(zt);
    t2.setName("子线程2");
    t2.start();

第二种方法：

  //这个任务只需使用一次
    Thread t=new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 1;  i< 100; i++) {
        System.out.println(Thread.currentThread().getName()+": "+i);
    }

        }
    });
    t.setName("子线程1");
    t.start();

第三种方法：

    //创建线程的同时 直接开启线程
    //不需要操作线程对象本身
    new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 1;  i< 100; i++) {
                System.out.println(Thread.currentThread().getName()+": "+i);
            }
        }
    }).start();

第四种方法：

  //使用Lambda表达式，但阅读性太差
    new Thread(()->{
        for (int i = 1;  i< 100; i++) {
            System.out.println(Thread.currentThread().getName()+": "+i);
        }
    }).start();
-2.线程的同步
  • 线程安全
    多个线程操作同一个资源，线程无法确定自己什么时候被阻塞，容易导致数据错误
  • 同步代码块
    synchronized (监听器/对象/锁){
    需要同步的代码
    }
  public class MyClass {
  public static void main(String[] args){
  Ticket ticketCQ=new Ticket("重庆");
  Thread t1=new Thread(ticketCQ);
  t1.start();
      }
  }
  class Ticket implements Runnable{
  //定义所有车票的数量
  public static int num=100;
  String name;
  public Ticket(String name){
      this.name=name;
  }
  // static实现同步(代码块)
  static final Object obj=new Object();
  @Override
  public void run() {
    for (int i = 1; i <= 100; i++) {
        synchronized (obj) {
            //需要同步的代码
            //判断有没有票
            if (num > 0) {
                System.out.println(name + "出票： " + num);
                num--;
            } else {
                break;
            }
          }
       }
    }
 }
  • 同步方法 同步监听器是同一个对象
    必须确保对象调用的同步操作时操作的统一对象
    public synchronized void test() {
    }
    本质都是同步代码块
    等价于
    synchronized (this){
    }
  class Ticket implements Runnable {
  public static int num = 100;
  String name;

  public Ticket(String name) {
      this.name = name;
  }
  static final Object obj = new Object();
  @Override
   public void run() {
      test();
   }

  public synchronized void test() {
    for (int i = 1; i <= 100; i++) {
        //需要同步的代码
        //判断有没有票
        if (num > 0) {
            System.out.println(name + "出票： " + num);
            num--;
        } else {
            break;
         }
      }
   }
}
-3.主线程和子线程之间使用数据回调
  public class MyClass {
  public static void main(String[] args){
  Person zs=new Person();
    zs.needHouse();
  }
}
class ZRThread implements Runnable{
@Override
public void run() {
    for (int i = 1;  i< 100; i++) {
        System.out.println(Thread.currentThread().getName()+": "+i);
        }
    }
}

分别定义两个类，在主函数中实现回调

  public class Person implements Agent.AgentInterface {
  public void needHouse(){
      Agent xw=new Agent();
      xw.target=this;
      xw.start();
  }

  @Override
  public void callBack(String desc) {
      System.out.println("我是小王，接收到你的数据了："+desc);
      }
  }

   public class Agent extends Thread{
   AgentInterface target;
   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName());
       System.out.println("开始找房子");
       System.out.println("—————————");
       System.out.println("房子找到了，即将返回数据");
       target.callBack("房子在西南大学");
       super.run();
   }
   public interface AgentInterface{
       void callBack(String desc);
       }
   }
-4.两个线程交替执行
  public class MyClass {
  public static void main(String[] args){
  Ticket ticketCQ=new Ticket("重庆");
    Thread t1=new Thread(ticketCQ);
    t1.start();
    Ticket ticketSH=new Ticket("上海");
    Thread t2=new Thread(ticketSH);
    t2.start();
    }
  }
  class Ticket implements Runnable{
  public static int num=100;
  String name;
  public Ticket(String name){
      this.name=name;
  }
  static final Object obj=new Object();
  static ReentrantLock lock=new ReentrantLock();
  @Override
  public void run() {
    for (int i = 1; i <= 100; i++) {
        synchronized (obj) {
            //需要同步的代码
            //判断有没有票
            if (num > 0) {
                System.out.println(name + "出票： " + num);
                num--;
                try {
                    //通知其他线程执行
                    obj.notify();
                    //当前线程等待
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                break;
            }
          }
        }
     }
  }
-5.线程间的通信

-使用ReentrantLock同步

  class Ticket implements Runnable{
  //定义所有车票的数量
  public static int num=100;
  String name;
  public Ticket(String name){
      this.name=name;
  }
  // static实现同步(代码块)
  //创建一个可重入的锁
  static ReentrantLock lock=new ReentrantLock();
  @Override
  public void run() {
      for (int i = 1; i <= 100; i++) {
          //加锁
          lock.lock();
              //需要同步的代码
              //判断有没有票
              if (num > 0) {
                  System.out.println(name + "出票： " + num);
                  num--;
              } else {
                  break;
              }
          //解锁
          lock.unlock();
      }
   }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • JAVA之多线程
    ▷ 进程、线程和多线程 进程： 定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统...
    默云客阅读 264评论 0赞 0
  • Java之多线程
    Thread（耦合，不推荐） Runnable（解耦，推荐） Executors ExecutorService ...
    如果仲有听日阅读 721评论 0赞 0
  • Java之多线程编程核心技术的6点整理
    开心一笑 【服务员来个西红柿炒鸡蛋，服务员：没有西红柿了。那来一个白菜炖豆腐，服务员：没有豆腐了……那好，来个鸡蛋...
    架构师启示录阅读 1,844评论 0赞 10
  • 游麦积山石窟
    游麦积山石窟 王学明 那苍然眩晕般耸立的似乎不是山，而是经数千年风...
    山之尖阅读 517评论 1赞 2
  • 最重要的是健健康康
    微博上一个博主，失联了9天，回来在微博上讲述了自己突发脑出血的事情。接下来，评论中开始说着“这夜，真的不能再熬了”...
    七萧萧阅读 113评论 0赞 0