第十章线程

金清泽

于 2021-06-29 20:41:05 发布

阅读量187

点赞数

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

本文链接：https://blog.csdn.net/m0_53752829/article/details/118343336

版权

Java 专栏收录该内容

18 篇文章 1 订阅

订阅专栏

学习目标：

学习线程内容

学习内容：

1、程序、进程、线程 2、创建线程 3、线程状态 4、多线程 5、线程同步 6、Lock（锁） 7、线程通信 8、新增创建线程方式

学习时间：

2021年6月28日 2021年6月29日

学习产出：

1、技术笔记 1 遍 2、CSDN 技术博客 1 篇

程序，进程，线程

程序：为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码

进程：正在执行的程序，从Windows角度讲，进程是操作系统进行资源分配的最小单位。

线程：进程可进一步细化为线程，是一个进程内部的最小执行单元，是操作系统进行任务调度的最小单元。

进程与线程关系

一个进程可以包含多个线程，一个线程只属于一个进程，线程不能脱离进程而独立运行。

每个进程至少包含一个线程（主线程）；在主线程中开始执行程序，java程序的入口main（）方式就是在主线程中被执行的。

在主线程中可以创建并启动其他线程。

一个进程内的所有线程共享该进程的内存资源。

创建线程

普通线程（main单线程）：

public class Sample { 
    public void method1(String str){
        System.out.println(str);
    }
    public void method2(String str){
        method1(str); 
    }
    public static void main(String[] args) { 
        Sample s = new Sample(); s.method2("hello!"); 
    } 
}

继承Thread类的方式

/*
  创建线程,在线程中写可以独立执行的任务代码
 */
public class MyThread extends Thread{
    //run中写我们需要执行的任务代码
    //Thread类中的run方法本身并不执行任何操作，如果我们重写了run方法，当线程启动时，它将执行 run方法。
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("MyThread:"+i);
        }
    }
}

public class Test {
    public static void main(String[] args) {
         //在主线程中创建一个线程,并启动它
        MyThread myThread = new MyThread();
          //myThread.run(); 启动线程不能调用run(),就是普通的方法调用
          myThread.start();//启动线程
        for (int i = 0; i <1000 ; i++) {
            System.out.println("main:"+i);
        }
    }
}

实现Runnable接口的方式

/*
   好处:避免了单继承的局限,提高了扩展性
 */
public class MyThread implements  Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("MyThread:"+i);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //线程要执行的任务
        MyThread myThread = new MyThread();
        //创建线程,并为线程指定执行任务
        Thread t = new Thread(myThread);
               t.start();

        for (int i = 0; i <10000 ; i++) {
            System.out.println("main:"+i);
        }
    }
}

继承方式和实现方式的联系与区别

区别

继承Thread: 线程代码存放Thread子类run方法中。

实现Runnable：线程代码存在接口的子类的run方法。

实现Runnable的好处

1）避免了单继承的局限性

2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

Thread类中方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B9Z2WG2J-1624970411611)(E:\Users\asus\AppData\Roaming\Typora\typora-user-images\1624964064360.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eYAKEP8q-1624970411618)(E:\Users\asus\AppData\Roaming\Typora\typora-user-images\1624964073868.png)]

public class MyThread implements  Runnable{
    //任务
    @Override
    public void run() {
             for(int i=0;i<1000;i++){
                 //currentThread()获得当前线程,getName()获得线程的名称
                 System.out.println(Thread.currentThread().getName()+":"+i);
             }
    }
}

public class Test {
    public static void main(String[] args) {
         MyThread myThread = new MyThread();
         Thread t1 = new Thread(myThread,"t1");//创建线程对象,添加执行任务,并命名
                t1.start();
         Thread t2 = new Thread(myThread,"t2");
                t2.start();
                t1.setPriority(10);//设置优先,高优先级的执行优先权高(不是一直执行完)
                t2.setPriority(1);
       /*for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }*/
        System.out.println("=========="+t1.getPriority());//获得线程优先级
        System.out.println("=========="+t2.getPriority());
    }
}

程序优先级

事实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能执行任务；

优先级较高的线程有更多获得CPU的机会，反之亦然；

优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级；

调整策略

时间片：给线程分配时间单位，一个时间片结点只能有一个线程运行

抢占式：高优先级的线程，有更多执行权，但不是说低优先级就没有机会

线程状态

线程在它生命周期中会处于不同的状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0l6vLjH5-1624970411621)(E:\Users\asus\AppData\Roaming\Typora\typora-user-images\1624964899043.png)]

线程的状态：

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对对象处于新建状态。

就绪：处于新建状态的线程被start（）后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源。

运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能。

阻塞：在某种特殊情况下，被认为挂机或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态。

死亡：线程完成了它的全部工作或者线程被提前强制性地中止或出现异常导致结束。

public class MyThread implements  Runnable{
    //任务
    @Override
    public void run() {
         for(int i=0;i<1000;i++){
            try {
                 Thread.sleep(100);//sleep()让线程休眠指定的时间
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             currentThread()获得当前线程,getName()获得线程的名称
             if(i%10==0){
                 Thread.yield();//线程让步
             }
             System.out.println(Thread.currentThread().getName()+":"+i);
         }

    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
         MyThread myThread = new MyThread();
         Thread t1 = new Thread(myThread,"t1");//创建线程对象,添加执行任务,并命名
                t1.start();
               t1.join();//等待该线程终止,其他线程进入到阻塞状态
        Thread t2 = new Thread(myThread,"t2");//创建线程对象,添加执行任务,并命名
                t2.start();*/
        for (int i = 0; i <1000 ; i++) {
            System.out.println("main线程"+i);
        }
    }
}

线程的分类

Java中的线程分为用户线程和守护线程

用户线程就是我们平时所写的线程，只需要关心自己的执行，不用管其他人的工作，直到线程死亡。

守护线程需要保护线程的运行，只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作，当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。

守护线程的作用是为其他线程的运行提供便利服务，守护线程的典型引用就是GC（垃圾回收器）

设置线程为守护线程必须在启动线程之前，否则跑出一个IllegalThreadStateException异常。

/*
 用户线程
 */
public class ThreadDemo1 extends  Thread{
    Socket socket;
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            /*try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

/*
  守护线程
 */
public class ThreadDemo2 extends  Thread{
    @Override
    public void run() {
         while(true){
             /*try {
                 Thread.sleep(100);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }*/
             System.out.println("我是守护线程,我在默默到的守护者你");
         }
    }

}

public class Test {

    public static void main(String[] args) {
        ThreadDemo1 userThread = new ThreadDemo1();
                    userThread.start();

        ThreadDemo2 sh = new ThreadDemo2();
                      sh.setDaemon(true);//设置线程2为守护线程,必须在启动前设置
                      sh.start();
    }
}

多线程的概念

多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的程序来完成各自的任务。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wmf24oB3-1624970411623)(E:\Users\asus\AppData\Roaming\Typora\typora-user-images\1624965842547.png)]

何时需要多线程：

程序需要同时执行两个或多个任务；

程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等；

需要一些后台运行的程序时。

多线程的优点

提高程序的响应；

提高CPU的利用率；

改善程序结构，将复杂任务分为多个线程，独立运行

多线程的缺点

线程也是程序，所以线程需要占用内存，线程越多占用内存也越多

多线程需要协调和管理，所以需要CPU时间跟踪线程

线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题

解决办法：加锁

线程同步

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀，多个人做同一件事

并发也就是同一个对象被多个线程同时操作

多线程同步

多个线程同时读写同一份共享资源时，可能会引起冲突。所以引入线程“同步”机制，即各个线程间要有先来后到

同步就是排队+锁：

几个线程之间要排队，一个个对共享资源进行操作

为了保证数据在方法中被访问时的正确性，在访问时加入锁机制

模拟售票：

继承Thred实现

/*
售票的线程
 */
public class TicketThread extends Thread{
          static int num = 10;//票数  共享资源
          static Object obj = new Object();//保证只有一个
    @Override
    public void run() {
        while(true){
            if(num>0){
               print();
            }else{
                break;
            }
        }
    }
    /*
      synchronized（同步监视器）在修饰方法时,同步对象(锁), 默认是this  一旦创建多个线程对象(只针对继承Thread类的方式)
      static修饰后,同步对象变为 线程类(类只有一个)
     */
    public static synchronized void print(){
          if(num>0){
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println(Thread.currentThread().getName()+"售出票:"+num);//0
              //线程1再减之前   0
              num--;
          }
    }
      /*  @Override
        public void run() {
           while(true){
               //synchronized(同步锁,就是一个对象,但是要求对象只有一个)
               synchronized(obj){
                   if(num>0){
                       try {
                           Thread.sleep(1000);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       System.out.println(Thread.currentThread().getName()+"售出票:"+num);//0
                       //线程1再减之前   0
                       num--;
                   }else{
                       break;
                   }
               }//同步代码块,执行完成后 同步对象(锁) 会自动释放
           }
        }*/
}

public class Test {

    public static void main(String[] args) {
        TicketThread t1 = new TicketThread();
                     t1.setName("窗口1");

        TicketThread t2 = new TicketThread();
                     t2.setName("窗口2");

                  t1.start();
                  t2.start();
    }
}

Runnable实现

public class TicketThread  implements  Runnable{
       int num = 10;//共享变量

    @Override
    public void run() {
        while(true){
                if(num>0){
                    print();
                }else{
                    break;
                }
        }
    }

    //synchronized 默认同步锁对象是this
    public synchronized void print(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if(num>0){
            System.out.println(Thread.currentThread().getName()+":"+num);
             num--;
         }
    }

   /* @Override
    public void run() {
            while(true){
                //添加同步对象,这种方式可以使用this来表示锁对象
                synchronized (this){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if(num>0){
                        System.out.println(Thread.currentThread().getName()+":"+num);
                        num--;
                    }else{
                        break;
                    }
                }
            }
    }*/
}

public class Test {
    public static void main(String[] args) {
        //创建出票任务
        TicketThread ticketThread = new TicketThread();
        
        //两个线程执行一个任务  num是只有一个的
        Thread t1 = new Thread(ticketThread,"窗口1");
        Thread t2 = new Thread(ticketThread,"窗口2");
              t1.start();
              t2.start();
    }
}

Lock（锁）

从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的

工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

public class TicketThread  implements  Runnable{

       int num = 10;//共享变量
       Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
                if(num>0){
                    print();
                }else{
                    break;
                }
        }
    }

    public void print(){
        //System.out.println("ssss");
        try {
            lock.lock();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(num>0){
                System.out.println(Thread.currentThread().getName()+":"+num);
                num--;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();//在finally中释放 锁
        }
        //System.out.println("ssssssssssss");
    }
}

public class Test {
    public static void main(String[] args) {
        //创建出票任务
        TicketThread ticketThread = new TicketThread();
        //两个线程执行一个任务  num是只有一个的
        Thread t1 = new Thread(ticketThread,"窗口1");
        Thread t2 = new Thread(ticketThread,"窗口2");
              t1.start();
              t2.start();
    }
}

线程死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

设计时考虑清楚锁的顺序，尽量减少嵌套的加锁交互数量。

public class DieLock extends  Thread{

    static Object objA = new Object();
    static Object objB = new Object();
     boolean  flag;
    public DieLock(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
          if(flag){//线程1
              synchronized (objA){
                  System.out.println("ifObjA");
                  synchronized (objB){
                      System.out.println("ifObjB");
                  }
              }
          }else{//线程2
             synchronized (objB){
                 System.out.println("elseBbjB");
                 synchronized (objA){
                     System.out.println("elseObjA");
                 }
             }
          }
    }
}

public class Test {
    public static void main(String[] args) {
        DieLock dieLock1 = new DieLock(true);
        DieLock dieLock2 = new DieLock(false);
        dieLock1.start();
        dieLock2.start();
    }
}

线程通信

线程通信指的是对个线程通过消息传递实现相互牵制，相互调度，即线程间的相互作用。

设计三个方法：

.wait() 一旦执行此方法，当前线程就进入了阻塞状态，并释放同步监视器

.notify() 一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个

.notifuAll() 一旦执行此方法，就会唤醒所有被wait的线程

说明：

.wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方

法中。

.wait()，notify()，notifyAll()三个方法是定义在java.lang

.Object类中。

案例：消费者问题

/*
    柜台 只有一个
 */
public class Counter {
       int  num = 0;

       /*
         添加
        */
     // 同步对象时this  就是同一个Counter对象
     public synchronized void add(){
           if(num==0){
               num++;
               System.out.println("生产者线程生产了一个商品");
               this.notify();//唤醒消费者
           }else{
               try {
                   this.wait();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
     }


       /*
         取
        */
     public synchronized void sub(){
         if(num>0){
             num--;
             System.out.println("消费者线程消费了一个商品");
             this.notify();
         }else{
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
}

/*
  消费者线程
 */
public class CustomerThread extends  Thread{

     Counter counter;

    public CustomerThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            counter.sub();
        }
    }
}

/*
   生产者
 */
public class ProductorThread extends Thread{

    Counter counter;

    public ProductorThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            counter.add();
        }
    }

public class Test {
    public static void main(String[] args) {
        Counter c = new Counter();//两个线程共享的资源  柜台
        ProductorThread p = new ProductorThread(c);
        CustomerThread cu = new CustomerThread(c);
                 p.start();
                 cu.start();
    }
}

新增创建线程方式（Callable）

实现Callable接口与使用Runnable相比，Callable功能更强大些.

相比run（）方法，可以有返回值

方法可以抛出异常

支持泛型的返回值

需要借助FutureTask类，获取返回结果

public class MyThread  implements Callable<Integer> {

    /*
        可以有返回值,可以泛型定义
        可以抛出异常
     */
    @Override
    public Integer call() throws Exception {
            int num = 0;
            num = 10;
            for (int i = 0; i <10 ; i++) {
                  num+=i;
            }
        return num;
    }
}

public class Test {

    public static void main(String[] args) {
        MyThread myThread  = new MyThread();

        FutureTask<Integer> futureTask = new FutureTask(myThread);//添加
        Thread t = new Thread(futureTask);
                t.start();

        try {
            Integer res =     futureTask.get();
            System.out.println(res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}