javaSE(九):线程

最新推荐文章于 2024-09-05 11:00:53 发布

404_NOT_FOUND@

最新推荐文章于 2024-09-05 11:00:53 发布

阅读量1k

点赞数 26

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/m0_70830675/article/details/137873930

版权

JavaSE 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

一、程序,进程,线程

1.概念

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

②进程((process)正在内存中运行的应用程序，如运行中的QQ，运行中的音乐播放器。进程是操作系统进行资源分配的最小单位.

③线程(thread)进程可进一步细化为线程，是一个进程内部的最小执行单元，是操作系统进行任务调度的最小单元，隶属于进程.

2.三者之间的关系：

● 一个进程可以包含多个线程；

● 一个线程只能属于一个进程，线程不能脱离进程而独立运行；

● 每一个进程至少包含一个线程(称为主线程)；

● 在主线程中可以创建并启动其它的线程；

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

public class Demo {
    public static void main(String[] args) {
          /*
          此段程序只能按照从上向下的顺序执行
          因为是单线程的，只有main这一个程序
          */

        System.out.println("main开始执行");
        methodA();
        methodB();
        System.out.println("main结束执行");
    }

    public static void methodA(){
        System.out.println("methodA");
    }

    public static void methodB(){
        System.out.println("methodB");
    }

}

输出结果：

main开始执行
methodA
methodB
main结束执行

二、创建线程

①继承Thread类的方式

●在Java中要实现线程，最简单的方式就是扩展Thread类，重写其中的run方法，方法原型如下：

● Thread类中的run方法本身并不执行任何操作，如果我们重写了run方法，当线程启动时，它将执行run方法。

public class MyThread extends Thread {
    /*
    java中创建线程方式1：
       写一个类继承java.lang.Thread
       重写run()
    */
    /*
      线程中要执行的任务都要写在run()中，或者在run()中进行调用
    */
    @Override
    public void run() {
        this.test();
    }

    public void test(){
        for (int i = 0; i < 1000; i++) {
            System.out.println("MyThread:"+i);
        }
    }

 public static void main(String[] args) {
        //创建并启动线程
        MyThread myThread = new MyThread();
       // myThread.run();//这不是启动线程，只是一个方法的调用，没有启动线程，还是单线程模式的
        myThread.start();

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

}

输出部分结果展示：

②实现Runnable接口的方式

● java.lang.Runnable接口中仅仅只有一个抽象方法：

●也可以通过实现Runnable接口的方式来实现线程，只需要实现其中的run方法即可；

● Runnable接口的存在主要是为了解决Java中不允许多继承的问题。

 /*java中创建线程方式2:
        只先创建要执行的任务，创建一个类，实现Runnable接口
        重写任务执行中的run
 */

public class Task implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("自定义线程:"+i);
        }
    }

public static void main(String[] args) {
        //创建任务
        Task task = new Task();
        //创建线程，并为线程指定执行任务
        Thread thread = new Thread(task);
        thread.start();

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

}

输出部分结果展示：

【实现Runnable接口创建的优点】
1）因为java是单继承，一旦继承一个类就不能继承其他类，避免单继承的局限性
2）多个线程可以共享同一个接口实现类的对象，适合多线程来处理同一份资源使用

三、Thread类中方法

1.常用方法

Thread类中的方法：

1.线程中要执行的任务都要写在run()中

run(); 用来定义线程要执行的任务代码
currentThread(); 获取当前线程
getId(); 获取线程的id
getName();获取线程的名字
getPriority();获取线程优先级
getState();获取线程状态
sleep(); 让线程阻塞休眠指定的时间
yield();主动礼让 退出cpu

2.创建线程对象时调用的方法

start(); 启动线程的
setPriority();设置线程优先级  优先级为1-10，默认是5，作用是为操作系统调度算法提供的
setName();为线程设置名字
join();等待调用了join()线程执行完毕，其他线程再执行

public class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getId());
            System.out.println(Thread.currentThread().getName());
            System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority());
            System.out.println(Thread.currentThread().getState());
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        Thread thread = Thread.currentThread();//获取当前正在执行的程序
        System.out.println(thread.getName());

     for (int i = 0; i < 100; i++) {
            Thread thread = Thread.currentThread();//获取当前正在执行的线程
            if (i%10 ==0) {
                Thread.yield();//主动礼让 退出cpu
            }
            System.out.println(thread.getName()+":"+i);
        }
    }
}

public class ThreadTest {

    public static void main(String[] args) throws InterruptedException {
        
        MyThread myThread = new MyThread();
        System.out.println(myThread.getState());
        myThread.setName("窗口1");
        myThread.setPriority(5);
        myThread.start();
       // myThread.join();//等待调用了join()线程执行完毕，其他线程再执行
        System.out.println(myThread.getState());

        MyThread myThread1 = new MyThread();
        myThread1.setName("窗口2");
        myThread1.setPriority(1);
        myThread1.start();
    }
}

2.线程优先级

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

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

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

●调度策略

①时间片

②抢占式：高优先级的线程抢占CPU

●Java的调度方法

①同优先级线程组成先进先出队列，使用时间片策略

②对高优先级，使用优先调度的抢占式策略

● Thread类有如下3个静态常量来表示优先级

①MAX_PRIORITY：取值为10，表示最高优先级。

②MIN_PRIORITY：取值为1，表示最底优先级。

③NORM_PRIORITY：取值为5，表示默认的优先级。

四、线程状态

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

②线程的状态

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

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

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

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

运行到阻塞状态：

①sleep()

    try {
          Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

②join()

MyThread myThread = new MyThread();
        System.out.println(myThread.getState());
        myThread.setName("窗口1");
        myThread.setPriority(5);
        myThread.start();
        myThread.join();//等待调用了join()线程执行完毕，其他线程再执行
        System.out.println(myThread.getState());

③Scanner 控制台输入

Scanner scanner = new Scanner(System.in);
        scanner.nextInt();

④等待同步锁

⑤wait()

阻塞到就绪状态：

①sleep()时间到

②调用了join线程执行完了

③用户在控制台已输入

④获取同步锁

⑤notify(),其他线程唤醒

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

运行到死亡状态：

①执行完run()

②调出线程的stop()

③出现异常并未处理

 System.out.println(10/0);//线程中出现异常，并没有处理——死亡
        for (int i = 0; i < 100; i++) {
            Thread thread = Thread.currentThread();//获取当前正在执行的线程
            if (i%10 ==0) {
                Thread.yield();//主动礼让 退出cpu
            }
            System.out.println(thread.getName()+":"+i);
        }

五、多线程

1.概念

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

2.何时需要多线程

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

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

3.多线程的优点

● 提高程序的响应.

● 提高CPU的利用率.

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

4.多线程的缺点

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

● 多线程需要协调和管理，所以需要跟踪管理线程,使得cpu开销变大；

● 线程之间同时对共享资源的访问会相互影响,如果不加以控制会导致数据出错.

六、线程同步

1.多线程同步

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

2.同步就是排队+锁

● 几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作；

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

3.例题

模拟卖票，两个窗口分别售票,票数为10张，分别使用继承Thread和实现Runnable两种方式实现

①继承Thread 类

synchronized同步代码块

public class TicketThread extends Thread{
     static int num = 10;//模拟有10张票
     static  Object obj = new Object();

   /*
      synchronized (同步锁对象){
            同步代码块
      }
   */

    @Override
    public void run() {
       while(true){
          synchronized (obj){//obj对象作用：记录有没有线程进入到同步代码块  要求：多个线程对应同一个同步锁对象
              if (num>0) {
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      throw new RuntimeException(e);
                  }
                  System.out.println(Thread.currentThread().getName()+"买到了第"+num+"张票");
                  num--;
              }else{
                  break;
              }
          }

        }
    }

     public static void main(String[] args) {

        TicketThread t1 = new TicketThread();
        t1.setName("窗口1");
        t1.start();

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

}

synchronized同步方法

public class TicketThread extends Thread{
     static int num = 10;//模拟有10张票

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

    public static synchronized void print(){
        if (num>0) {
            System.out.println(Thread.currentThread().getName()+"买到了第"+num+"张票");
            num--;
        }
    }

     public static void main(String[] args) {

        TicketThread t1 = new TicketThread();
        t1.setName("窗口1");
        t1.start();

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

}

②实现Runnable接口

synchronized同步代码块

public class TicketTask implements Runnable {

    int num = 10;

    @Override
    public void run() {
         while(true){
                synchronized (this){
                    if (num>0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        System.out.println(Thread.currentThread().getName()+"买到了第"+num+"张票");
                        num--;
                    }else{
                        break;
                    }
                }
           }
    }
     public static void main(String[] args) {
        //只需要创建一个出票任务
        TicketTask ticketTask = new TicketTask();

        Thread t1 = new Thread(ticketTask);
        t1.setName("窗口1");
        t1.start();

        Thread t2 = new Thread(ticketTask);
        t2.setName("窗口2");
        t2.start();
    }
}

synchronized同步方法

public class TicketTask implements Runnable {

    int num = 10;

    @Override
    public void run() {
        while(true){
            if (num<=0){
                break;
            }
            this.print();
        }
    }

    public synchronized void print(){
        if (num>0) {
            System.out.println(Thread.currentThread().getName()+"买到了第"+num+"张票");
            num--;
        }
    }
     public static void main(String[] args) {
        //只需要创建一个出票任务
        TicketTask ticketTask = new TicketTask();

        Thread t1 = new Thread(ticketTask);
        t1.setName("窗口1");
        t1.start();

        Thread t2 = new Thread(ticketTask);
        t2.setName("窗口2");
        t2.start();
    }

}

输出结果：

4.同步锁机制

确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁，哪个线程获取了这把锁，才有权利访问该共享资源。

● 在Java代码中实现同步：

使用synchronized(同步锁对象)关键字同步代码块

synchronized (同步锁）{

// 需要被同步的代码；

}

synchronized还可以放在方法声明中，表示整个方法,为同步方法

public synchronized void show (String name){

// 需要被同步的代码；

}

5.同步锁

同步锁可以是任何对象,必须唯一,保证多个线程获得是同一个对象(用来充当锁标记).

6.同步执行过程

①第一个线程访问，锁定同步对象，执行其中代码.

②第二个线程访问，发现同步对象被锁定，无法访问.

③第一个线程访问完毕，解锁同步对象.

④第二个线程访问，发现同步对象没有锁，然后锁定并访问.

七、Lock（锁）

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

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

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

public class TicketThread extends Thread{

    static int num = 10;
    static ReentrantLock  reentrantLock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                reentrantLock.lock();//0-1  加锁
                if (num > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + "买到了第" + num + "张票");
                    num--;
                } else {
                    break;
                }
            } finally {
                reentrantLock.unlock();//1-0 释放锁
            }
        }
    }
     public static void main(String[] args) {

        TicketThread t1 = new TicketThread();
        t1.setName("窗口1");
        t1.start();

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

}

synchronized 和 reentrantLock区别：
synchronized是一个关键字，控制依靠底层编译后的指令执行去实现
synchronized可以修饰一个方法，还可以修饰一个代码块
synchronized是隐式的加锁和释放锁，一旦方法和代码块中运行结束或出现异常，会自动释放锁

reentrantLock是一个类，是依靠java代码去控制(底层有一个同步队列)
reentrantLock只能修饰代码块
reentrantLock需要手动的加锁，手动的释放锁，所以释放锁最好写在finally中，一旦出现异常，保证锁能释放

八、线程通信

1.例题引入

● 两个线程交替打印1-100之间的数字

public class PrintNumThread extends Thread{

    static int num = 1;
    static  String obj = new String();//同步锁

    @Override
    public void run() {
        while(num<100){
            synchronized (obj){
                obj.notify();//唤醒等待的线程
                System.out.println(Thread.currentThread().getName()+":"+num);
                num++;
                try {
                    obj.wait();//让线程等待，会自动地释放锁, notify(),wait(),必须在同步代码块中使用，必须是通过锁对象调用的
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }

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

        PrintNumThread p2 = new PrintNumThread();
        p2.start();
    }
}

输出部分结果：

2.概念

线程通讯指的是多个线程通过相互牵制，相互调度，即线程间的相互作用。

涉及三个方法：

①wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步锁对象。

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

③notifyAll一旦执行此方法，就会唤醒所有被wait的线程。

！！！注意：

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

3.经典例题：生产者/消费者问题

● 生产者(Productor)将产品放在柜台(Counter)，而消费者(Customer)从柜台处取走产品，生产者一次只能生产固定数量的产品(比如:1），这时柜台中不能再放产品,此时生产者应停止生产等待消费者拿走产品,此时生产者唤醒消费者来取走产品,消费者拿走产品后,唤醒生产者,消费者开始等待

分别创建四个类CustmoerThread消费者线程；ProductorThread生产者线程；Counter柜台用于添加，拿走商品；Test用于测试，创建线程

public class CustmoerThread extends Thread{

    Counter counter;

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

    @Override
    public void run() {
        while(true){//消费者线程一直消费
            try {
                this.counter.sub();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class ProductorThread extends Thread {

    Counter counter;

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

    @Override
    public void run() {
        while(true){//生产者线程一直生产
            try {
                this.counter.add();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

//柜台
public class Counter {

     static int num = 1;//柜台可以存放的商品数量

     //生产者线程调用 添加商品
     public synchronized void add() throws InterruptedException {//锁对象是this,两个方法共用一把锁
          if (num==0){
              this.notify();
              num=1;
               System.out.println("生产者线程生产了一件商品");
          }else{
               this.wait();
          }
     }
     //消费者线程调用 拿走商品
     public synchronized void sub() throws InterruptedException {
          if (num>0){
               this.notify();
               num=0;
               System.out.println("消费者线程消费了一件商品");
          }else{
               this.wait();
          }
     }

}

public class Test {
    public static void main(String[] args) {

        Counter counter = new Counter();//只创建一个柜台对象

        ProductorThread productorThread = new ProductorThread(counter);
        productorThread.setName("生产者线程");

        CustmoerThread custmoerThread = new CustmoerThread(counter);
        custmoerThread.setName("消费者线程");

        productorThread.start();
        custmoerThread.start();
    }
}

输出结果：

九、新增创建线程方式

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

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

• 方法可以抛出异常

• 支持泛型的返回值

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

接收任务

FutureTask futureTask = new FutureTask(任务);

创建线程

Thread t = new Thread(futureTask);

t.start();

Integer val = futureTask.get();获得线程call方法的返回值

public class SumTask<T> implements Callable<T> {


    @Override
    public T call() throws Exception {
        Integer n = 0;
        for (int i = 0; i < 10; i++) {
            n+=i;
        }
        Thread.sleep(1000);
        return (T)n;
    }
     public static void main(String[] args) throws ExecutionException, InterruptedException {
        SumTask<Integer> sumTask = new SumTask();
        FutureTask<Integer> futureTask = new FutureTask<>(sumTask );
        Thread thread = new Thread(futureTask);
        thread.start();

        Integer sum = futureTask.get();//获取call方法返回的执行结果
        System.out.println(sum);
    }
}

输出结果：

45

404_NOT_FOUND@

关注

26
点赞
踩
29

收藏

觉得还不错? 一键收藏
1
评论
javaSE(九):线程

①是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码.②正在内存中运行的应用程序，如运行中的QQ，运行中的音乐播放器。进程是操作系统进行资源分配的最小单位.③进程可进一步细化为线程，是一个进程内部的最小执行单元，是操作系统进行任务调度的最小单元，隶属于进程.●一个进程可以包含多个线程；● 一个线程只能属于一个进程，线程不能脱离进程而独立运行；● 每一个进程至少包含一个线程(称为主线程● 在主线程中可以创建并启动其它的线程；
复制链接

扫一扫

专栏目录