多线程学习Java

多线程

1.1基本概念：程序、进程、线程

程序：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象
进程：是程序的一次执行过程，或是正运行的一个程序。是动态的过程：有自身的产生、存在和消亡的过程。——声明周期
如：运行中的QQ
- 程序是静态的，进程是动态的
进程作为资源分配的单位，系统在运行时会为每个进程分配不同内存的区域
线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。
- 若一个进程同一时间并行多个线程，就是支持多线程
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小
- 一个进程中的多个线程共享相同的内存单元/内存地址空间->它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间的通讯更简便、高效。但多个线程操作共享系统资源可能就会带安全隐患

*** 虚拟机栈和程序计数器是一个线程一份，而方法区和堆是一个进程一份，所有所有线程共享方法区和堆 ***

1.2单核cpu和多核cpu:

单核cpu其实是一种假的多线程，因为在一个时间内只能执行一个线程任务。假如有A、B线程任务，单核CPU就是先执行一个然后挂起再去执行一会另一个，来回切换执行，但因为CPU时间特别短所以感觉不出来；
多核才能更好发挥多线程
一个Java应用程序最少三个线程：main()主线程、gc()垃圾回收线程，异常处理线程

1.3并行和并发

并行：多个CPU同时执行多个任务
并发：一个CPU（采用时间片）“同时”执行多个任务

1.4多线程的优点

1.提高应用程序的影响。对图形化界面更有意义，可增强用户体验

2.提高CPU利用率

3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

何时需要多线程

程序需要同时执行两个或多个任务
程序需要实现一些需要等待的任务，如用户输入，文件读写等
需要一些后台运行时的程序

2线程的创建和使用

2.1方式1：继承Thread类

1.创建一个基承Thread类的子类
2.重写Thread类的run()方法-->将此线程的操作声明在run方法中
3.创建Thread类的子类对象
4.通过此对象调用start()

/**
 *
 * 多线程的创建方式1：基础Thrad类
 *  * 1.创建一个基承Thread类的子类
 *  * 2.重写Thread类的run()方法-->将此线程的操作声明在run方法中
 *  * 3.创建Thread类的子类对象
 *  * 4.通过此对象调用start()
 *
 */
//1.创建一个基承Thread类的子类
class MyThread extends Thread{
//    2.重写Thread类的run()方法
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2==0){
                System.out.println(i);
            }

        }

    }
}
public class ThreadTest  {
    public static void main(String[] args) {
//        3.创建Thread类的子类对象
        MyThread t1 = new MyThread();//主线程做的
//        4.通过此对象调用start():1启动当前线程；2调用当前线程的run()方法
        t1.start();//主线程做的之后run()操作才是支线

        //问题1：不会开启新线程，只是调用方法还是主线程
       //  t1.run();

        //问题二：在启动一个线程，遍历100以内的偶数。不可以让已经start()的线程去执行，会报异常
//        t1.start();

        //需要重写创建一个线程对象
        MyThread t2 = new MyThread();
        t2.start();


//        如下操作仍然是在main线程中执行
        for (int i = 0; i <100 ; i++) {
            if (i%2==0){
                System.out.println(i+"=====main=====");
            }

        }
    }
}

联习：创建两个线程，其中一个线程遍历100以内的偶数，另外一个遍历100以内的奇数

方法1
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

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

class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2 !=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

方法2
public class ThreadDemo {
    public static void main(String[] args) {
//        创建Thread的匿名子类
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <100 ; i++) {
                    if(i%2==0){
                              System.out.println(Thread.currentThread().getName()+":"+i);
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <100 ; i++) {
                    if(i%2 !=0){
                        System.out.println(Thread.currentThread().getName()+":"+i);
                    }
                }
            }
        }.start();
    }
}

2.2Thread中的常用方法

1.start():启动当前线程；调用当前线程的run()方法

2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3.currentThread():静态方法，返回执行当前代码的线程

4.getName():获取当前线程的名字

5.setName():设置当前线程的名字

6.yield():释放当前cpu的执行权（重新抢）

7.join():在线程A中调用线程B的join（）方法，此时线程A进入阻塞状态，直到线程B执行完以后，A才能结束阻塞状态

8.stop():已过失，当执行此方法时强制结束线程

9.sleep(long millitime):让当前线程"睡眠"指定的millitime毫秒，在指定的时间内当前线程是阻塞状态

10.isAlive():判断当前线程是否还存活

 * 测试Thread中的常用方法
class HelloThread<publi> extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            if(i%2==0){
                try {
                    sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if (i%20==0){
                this.yield();
            }

        }
    }
    public HelloThread(String name){
        super(name);
    }
}

public class ThreadMethodTest {
    public static void main(String[] args) {
        //通过构造器方式给线程命名
        HelloThread h1 = new HelloThread("Thread:1");
//        h1.setName("线程一");
        h1.start();
//        给主线程命名
        Thread.currentThread().setName("主线程");
        for (int i = 0; i <100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i==20){
                try {
                    h1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
        System.out.println(h1.isAlive());
    }
}

2.3线程的优先级

线程优先级等级
- MAX_PRIORITY:10
- MIN_PRIORITY:1
- NORM_PRIORITY:5
涉及的方法：
- getPriority():返回线程优先值
- setPriority(int newPriority):改变线程优先级
说明
- 线程创建时继承父类的优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级之后才被调用

class HelloThread<publi> extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+getPriority()+":"+i);
            }
            if (i%20==0){
                this.yield();
            }

        }
    }
    public HelloThread(String name){
        super(name);
    }
}

public class ThreadMethodTest {
    public static void main(String[] args) {
        //通过构造器方式给线程命名
        HelloThread h1 = new HelloThread("Thread:一");
//        h1.setName("线程一");
//        设置分线程的优先级
        h1.setPriority(Thread.MAX_PRIORITY);
        h1.start();
//        给主线程命名
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i <100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
            }


        }

    }
}

联习：例子：创建三个窗口卖票，总票数为100

存在线程安全问题，待解决

class Window extends Thread{
    private static int ticket=100;

    @Override
    public void run() {
        while(true){
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
                ticket--;
            } else {
                break;
            }
        }

        }
    }

public class WindowTest {
    public static void main(String[] args) {
        Window t1=new Window();
        Window t2=new Window();
        Window t3=new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

如果不想给ticket加static需要用创建多线程的另一种方法

2.4方式2：实现Runnable接口

1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象做为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()

//1.创建一个实现了Runnable接口的类
class MThread implements Runnable{
    //2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }

    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
         MThread mThread = new MThread();
         //4.将此对象做为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        //5.通过Thread类的对象调用start()；1启动线程2调用当前线程run()-->调用Runnable类型中的target的run()
        t1.start();
        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.start();


    }
}

联习：例子：创建三个窗口卖票，总票数为100

 //存在线程安全问题，待解决

class Window1 implements Runnable{
    private int ticket=100;

    @Override
    public void run() {
        while (true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+":卖票，票号为"+ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}



public class WindowRunnableTest {
    public static void main(String[] args) {
        Window1 w = new Window1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");
        t1.start();
        t2.start();
        t3.start();
    }
}

2.5两种方式的对比

开发中优先选择：实现Runnable接口的方式

原因：1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合处理多个线程有共享数据的情况
联系：Thread类本身也是实现Runnable
相同点：两种方式都要重写run(),将线程要执行的逻辑声明在run()中

3线程的生命周期

五种状态：

新建：当一个Thread或其子类被对象声明并创建时
就绪：start()之后，已经具备运行的条件，只是没有分配到cpu资源
运行：当就绪的程序被调度并获得CPU资源时便进入了运行状态，run()方法定义了线程的操作和功能
阻塞：某种特殊情况下，被人为挂起或执行·1输入输出操作时，让出CPU并临时终止自己的执行。进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地终止或者异常导致结束

4线程的同步（解决线程安全问题）

1.问题：卖票过程中出现了重票。错票-->出现线程的安全问题

2.问题出现原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来也操作车票
3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来，直到该线程操作完，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能改变
4.在Java中，我们通过同步机制，来解决线程安全问题

方式一：同步代码块

synchronized(同步监视器){
//需要被同步的代码
}

*** 说明：1.操作共享数据的代码，即为需要被同步的代码不能包含代码多了也不能少了
2.共享数据：多个线程共同操作的数据
3.同步监视器，俗称：锁。任何一个类的对象都可以充当锁
要求：多个线程必须要共用同一把锁 ***

同步代码块解决实现Runnable接口线程安全问题：

补充：在继承Thread类创建多线程方式中，慎用this当同步监视器，考虑使用当前类充当同步监视器

class Window1 implements Runnable{
    private int ticket=100;
    Object obj=new Object();


    @Override
    public void run() {
        while (true){
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}


public class WindowRunnableTest {
    public static void main(String[] args) {
        Window1 w = new Window1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

同步代码块解决继承Thread线程安全问题：

补充：在继承Thread类创建多线程方式中，慎用this当同步监视器，考虑使用当前类充当同步监视器

class Window extends Thread{
    private static int ticket=100;
    private Object obj=new Object();
    private static Object obj2=new Object();

    @Override
    public void run() {
        while(true){
          //  synchronized (obj) {此时不唯一
            synchronized (obj2){
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }

    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window t1=new Window();
        Window t2=new Window();
        Window t3=new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

方式二：同步方法

5.同步的方式，解决了线程安全的问题---好处
操作同步代码时，只能有一个线程参与，其他线程等待。相但与一个单线程的过程--局限

5线程的通信

线程通讯的例子：使用两个线程打印1-100，线程1，线程2交替打印
涉及的三个方法：

wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait就唤醒优先级高的那个
notifyAll():一旦执行此方法，就会唤醒被wait的所有线程。

面试题： sleep()和wait()的异同？

1.相同：一旦执行方法，都可以使当前线程进入阻塞状态
2.不同点：1）两个方法声明的位置不一样：Thread类声明sleep(),Object类中声明wait()
2）调用的要求不同：sleep()可以在任何需要的场景调用。wait()必须使用在同步代码块或同步方法中
3）关于释放释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁

lass Number implements Runnable{
    private int number=1;

    @Override
    public void run() {
        while (true){
            //快捷键Alt+shift+z
            synchronized (this) {
                notify();
                if (number<=100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;
                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        wait();//会释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number n = new Number();
        Thread t1 = new Thread(n);
        Thread t2 = new Thread(n);

        t1.setName("线程1");
        t2.setName("线程2");

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

综合练习：线程通讯的应用：经典例题：生产者/消费者的问题

分析：
1是否多线程：是生产者，消费者线程
2是否有共享数据？是，店员（或产品）
3.如何解决线程安全问题？同步机制，有三种方法
4.是否涉及线程的通讯？是

class Clerk{
    private int productCount=0;

   //生产产品
    public synchronized void produceProduct() {
        if (productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
            notify();
        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    //消费参评
    public synchronized void cnsumerProduct() {
        if (productCount>0){
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
            productCount--;
            notify();
        }else {
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Producer extends Thread{//生产者
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+":开始生产产品。。");
    while (true){
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        clerk.produceProduct();
    }

    }
}

class Consumer extends Thread{//消费者
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+":开始消费产品。。");
        while (true){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.cnsumerProduct();
        }

    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Producer p1=new Producer(clerk);
        p1.setName("生产者1");

        Consumer c1=new Consumer(clerk);
        c1.setName("消费者1");

        p1.start();
        c1.start();
    }
}

6JDK5.0新增线程创建方式

新增方式一：实现Callable接口

与Runnable相比，Callable功能更强大些
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，比如获取返回结果
Future接口
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
- FutureTask是Future接口的唯一实现类
- Future Task同时实现了Runnabl、Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

步骤：

1.创建一个实现Callable的实现类
2.实行按call方法，将此线程需统执行的操作声明在call()中
3.创建Callable接口实现类的对象
4.将Callable接口实现类的对象作为参数传递到FutureTask的构造器中，创建Future Task对象
5.将Future Task的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
6.获取Callable中call方法的返回值(不需要可以不写)

/*
创建线程的方式3：实现Callable接口----JDK5.0新增
 */

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//1.创建一个实现Callable的实现类
class NumberThread implements Callable{
    //2.实行按call方法，将此线程需统执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 0; i <100; i++) {
            if (i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {

        //3创建Callable接口实现类的对象
        NumberThread numberThread = new NumberThread();
        //4.将Callable接口实现类的对象作为参数传递到FutureTask的构造器中，创建Future Task对象
        FutureTask futureTask = new FutureTask(numberThread);
        //5.将Future Task的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

新增方式二：使用线程池

提前创建好的多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。

好处：

提高响应速度（减少了创建线程的时间）
降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
便于线程管理
- corePoolSize:核心池的大小
- maximumPoolSize:最大连接线程数
- keepAliveTime:线程没有任务时最多保持多长时间后会终止

步骤

1.提供指定数量的线程池
2.执行指定的线程的操作，需要提供实现Runnable或Callable接口实现类的对象
3.关闭连接池

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <=100 ; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class NumberThread2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <=100 ; i++) {
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}



public class ThreadPoll {
    public static void main(String[] args) {
        //1.提供指定数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
        //设置线程池的属性
        System.out.println(service.getClass());//看看service接口的实现类

  //      service1.setCorePoolSize(15);


        //2.执行指定的线程的操作，需要提供实现Runnable或Callable接口实现类的对象
        service.execute(new NumberThread1());//适合使用于Runnable
        service.execute(new NumberThread2());
    //    service.submit();//适合使用于Callable

        //3.关闭连接池
        service.shutdown();//关闭连接池




    }
}

面试题：实现多线程有几种方式：

四种，继承Thread，实现Runnable接口、实现Callable接口，线程池

posted @ 2022-02-26 18:57 最爱吃鸡肉卷阅读(30) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 异常Java

· 抽象类和接口

· Java中的多线程

· Java进阶（一）-多线程

· 6、多线程

阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了

公告

昵称：最爱吃鸡肉卷
园龄： 3年
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

随笔档案

2022年2月(18)