JavaSe学习笔记09（线程）

最新推荐文章于 2023-06-14 17:20:14 发布
最新推荐文章于 2023-06-14 17:20:14 发布
阅读量351 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42845320/article/details/109437732
版权

JavaSe学习笔记 day09

Thread中的常用方法

  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毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
  10. isAlive():判断当前线程是否存活

线程的优先级：

  1. MAX_PRIORITY：10
    MIN _PRIORITY：1
    NORM_PRIORITY：5 -->默认优先级
  2. 如何获取和设置当前线程的优先级：
    getPriority():获取线程的优先级
    setPriority(int p):设置线程的优先级
  3. 说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
示例：h1.setPriority(Thread.MAX_PRIORITY)

Thread.currentThread().getPriority()

创建线程的方式

方式一：Thread

  1. 创建步骤
    1）创建一个继承于Thread类的子类
    2）重写Thread类的run() --> 将此线程执行的操作声明在run()中
    3）创建Thread类的子类的对象
    4）通过此对象调用start()
public class ThreadTest extends Thread{
	private int i = 0;
	public void run(){
		for(;i<100;i++){
			System.out.println(getName() + ' ' + i );
		}
	}
	public static void main(String[] args) {
		for(int i = 0; i<100;i++){
			System.out.println(Thread.currentThread().getName() + " " + i);
			if(i == 20){
				new ThreadTest().start();
				new ThreadTest().start();
			}	
		}
	}
}

创建多线程的方式二：实现Runnable接口

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

  2. 比较创建线程的两种方式。
    2.1 开发中：优先选择：实现Runnable接口的方式
    2.2 原因：
    a.实现的方式没有类的单继承性的局限性
    b. 实现的方式更适合来处理多个线程有共享数据的情况。

  3. 联系：public class Thread implements Runnable

  4. 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

public class RunnableTest implements Runnable{
	public void run(){
		for(int i = 0; i < 100;i++){
			System.out.println(Thread.currentThread().getName() 
					 + ":" + i);
		}
	}
	public static void main(String[] args) {
		Runnable r = new RunnableTest();
		for(int i = 0; i < 100;i++){
			System.out.println(Thread.currentThread().getName() + ":" +i);
			if(i == 20){
				new Thread(r,"新线程1").start();
				new Thread(r,"新线程1").start();
			}
		}
	}
}

创建线程的方式三：实现Callable接口。 — JDK 5.0新增

  1. 创建步骤
    1）创建一个实现Callable的实现类
    2）实现call方法，将此线程需要执行的操作声明在call()中
    3）创建Callable接口实现类的对象
    4）将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
    5）将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
    6）获取Callable中call方法的返回值
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; 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接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到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();
        }
    }

}

创建线程的方式四：使用线程池

好处：

  1. 提高响应速度（减少了创建新线程的时间）
  2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
  3. 便于线程管理
    corePoolSize：核心池的大小
    maximumPoolSize：最大线程数
    keepAliveTime：线程没有任务时最多保持多长时间后会终止
class NumberThread 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 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);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


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

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}
  1. 多线程总结:

提供指定线程数量的线程池ExecutorService service =Executors.newFixedThreadPool(10);
执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象service.execute(newNumberThread());
对于Callable接口，它的语句是service.submit(Callable callable)
关闭连接池service.shutdown();

5.创建线程的三种方式对比

采用实现Runnable、Callable接口的方式创建多线程的优缺点
优点：线程类只是实现了Runnable接口或Callable接口，还可以继承其他类，将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
缺点：编程稍微复杂，如果需要访问当前线程，则必须使用Thread.currentThread()方法
采用Thread类的方式创建多线程的优缺点
优点：编写简单，如需访问当前线程，无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。
缺点：因为线程类继承了Thread类，因此无法在继承其他父类。
鉴于上面分析，一般推荐采用实现Runnable接口、callable接口的方式来创建多线程。

线程的生命周期

1.概述：要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
1.1 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
1.2 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
1.3 运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
1.4 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
1.5 死亡：线程完成了它的全部工作或线程被提前强制性地中止
在这里插入图片描述

线程安全问题

关于售票问题的思考

  1. 问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
  2. 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
  3. 如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

同步机制，解决线程安全

  • 方式一：同步代码块
  synchronized(同步监视器){
     //需要被同步的代码
  }
  1. 在Java中，我们通过同步机制，来解决线程的安全问题。
    说明：
    1）操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。
    2）共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
    3）同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
    要求：多个线程必须要共用同一把锁。
    4）补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
    5）符合：加锁—>修改—>释放锁的逻辑
  • 方式二：同步方法。
    如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
  1. 同步的方式，解决了线程的安全问题。—好处
    操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 —局限性
  2. 总结
    1）同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
    2）非静态的同步方法，同步监视器是：this; 静态的同步方法，同步监视器是：当前类本身
懒汉式：
public class SingletonTest2 {
    public static void main(String[] args) {
    Order order1 = Order.getInstance();
    Order order2 = Order.getInstance();

    System.out.println(order1 == order2);

}

}
class Order{
//1.私有化类的构造器
private Order(){

}

//2.声明当前类对象，没有初始化
//4.此对象也必须声明为static的
private static Order instance = null;

//3.声明public、static的返回当前类对象的方法
public static Order getInstance(){

    if(instance == null){

        instance = new Order();

    }
    return instance;
}

}
线程安全的懒汉式：
public class BankTest {
}
class Bank{
private Bank(){}

private static Bank instance = null;

public static Bank getInstance(){
    //方式一：效率稍差

//        synchronized (Bank.class) {
//            if(instance == null){
//
//                instance = new Bank();
//            }
//            return instance;
//        }
//方式二：效率更高
if(instance == null){
        synchronized (Bank.class) {
            if(instance == null){

                instance = new Bank();
            }

        }
    }
    return instance;
}

}

方式三、 解决线程安全问题的方式三：Lock锁 — JDK5.0新增

  1. 面试题：synchronized 与 Lock的异同？
    相同：二者都可以解决线程安全问题
    不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
    Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
  2. 优先使用顺序：
    Lock -> 同步代码块（已经进入了方法体，分配了相应资源）-> 同步方法（在方法体之外）
import java.util.concurrent.locks.ReentrantLock;
class Window implements Runnable{
private int ticket = 100;
//1.实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();

@Override
public void run() {
    while(true){
        try{

            //2.调用锁定方法lock()
            lock.lock();

            if(ticket &gt; 0){

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + &quot;：售票，票号为：&quot; + ticket);
                ticket--;
            }else{
                break;
            }
        }finally {
            //3.调用解锁方法：unlock()
            lock.unlock();
        }

    }
}

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

    t1.setName(&quot;窗口1&quot;);
    t2.setName(&quot;窗口2&quot;);
    t3.setName(&quot;窗口3&quot;);

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

}
  1. 总结：
    实例化ReentrantLock：private ReentrantLock lock = new ReentrantLock();
    调用锁定方法lock()：lock.lock();
    调用解锁方法：unlock()lock.unlock();

死锁

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

  2. 说明：
    1）出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
    2）我们使用同步时，要避免出现死锁。

线程通信

  1. 线程通信的例子：使用两个线程打印 1-100。线程1, 线程2 交替打印
    涉及到的三个方法：
    wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
    notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
    notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。

  2. 说明：
    1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
    2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
    否则，会出现IllegalMonitorStateException异常
    3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。

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

class Thread1 implements Runnable {

    private int number = 1;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                this.notify(); // 唤醒被wait()的线程
                if (number <= 100) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ": number" + number);
                    number++;
                    try {
                        // 调用wait()方法的线程,进入阻塞状态
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}
轻雨黯然
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程的使用
qq_43658407的博客
03-25 2000
1. 多线程 多任务执行,多路径执行 优点: 1.提高性能。 2.提高效率。 进程与线程之间的区别: 进程 : 系统中的程序,一个进程之间可以包含1~n个线程,系统中资源分配的最小单位,每个进程都有自己的代码与数据空间,进程之间的切换开销较大。 线程 : 程序中的顺序流,线程是cpu调度与执行的最小单位,多个线程之间共享进程的代码和数据空间,每一个线程都有自己的程序计数器运行栈,线程之间切换开销较小。 注意：一个cpu同一时刻只能调度一个线程。 创建线程的方式 : 1.继
实现多线程的4种方式
YIYIYI
09-23 1019
实现多线程的4种方式
编程必备：JAVA多线程详解
拾一二的博客
06-14 7888
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java——多线程使用详解
itzhuzhu的博客
10-01 921
目录： 并发与并行 线程与进程 创建线程 start和run的区别 获取和修改线程的名称 获取当前线程 线程睡眠 实现接口创建线程 匿名内部类创建线程 1.并发与并行： 并行: 两个或以上的事件在同一时刻发生(同时发生) 举例:比如12:30:30,一个小朋友一边吃饭,一边打电话 并发: 两个或以上的事件在一个时间段内发生(交替执行) 举例:比如12:30~12:35这个时间段内一个...
多线程使用方法
weixin_41071226的博客
07-18 664
多线程使用方法
非常详细javaSE学习笔记.rar
10-21
这份“非常详细JavaSE学习笔记.rar”压缩包显然是一份全面的Java SE学习资源，包含了从基础知识到高级特性的全方位讲解。下面，我们将详细探讨这份笔记可能涵盖的关键知识点。 1. **Java起源与环境搭建**：笔记可能...
JavaSE学习笔记.rar
08-19
这个学习笔记包含了Java开发的基础阶段知识，是初学者掌握Java编程语言的关键。以下将详细解析JavaSE中的主要知识点： 1. **Java基础语法**：Java是一种强类型、面向对象的编程语言，它的基础语法包括变量声明、...
黑马程序员Javase笔记
01-18
"黑马程序员Javase笔记"是一个自学者在学习黑马程序员提供的Java全套课程过程中整理的笔记，主要涵盖了Java Standard Edition (Javase) 的核心内容。下面将详细讨论其中的关键知识点。 首先，DOS命令是操作系统中的...
JAVASE学习笔记
09-03
《JavaSE学习笔记详解》 JavaSE，全称为Java Standard Edition，是Java平台的核心部分，主要针对桌面应用和服务器端应用开发。对于初学者或有经验的开发者来说，深入理解和熟练掌握JavaSE的基础知识至关重要。以下...
多线程使用
明日大牛的博客
03-25 83
多线程使用
多线程的最全基本操作用法
starry1441的博客
04-30 483
线程 进程是系统分配资源的最小单位，线程是系统调度的最小单位。一个进程内的线程之间是可以共享资源 的
关于多线程的基本使用
weixin_46913652的博客
06-28 214
本文只是对多线程的一些简单实用（多核情况），比如数据库插入数据，计算数据（互不干扰，无需依赖上一个计算数据的）。
iPhone开发进阶（11）— 多线程的使用与注意事项
itudou_2010的专栏
04-25 1376
博主：易飞扬原文链接 : http://www.yifeiyang.net/iphone-developer-advanced-11-multiple-threads-of-use-and-precautions/转载请保留上面文字。 从例子入手 使用线程的注意事项 线程的堆栈大小 Autorelease 子线程中描画窗口iPhone开发进阶（11）--- 多线程的使用与注
如何用多线程实现归并排序
菜鸟修仙记
08-09 7416
等我有时间了，一定要把《算法导论》啃完，这本书的印刷质量实在太好了，滑稽。 之前听吴恩达老大说过Python里面的Numpy包的矩阵运算就是多线程的，所以能做到的情况下尽量用矩阵运算代替循环，这样能大大加快运算的速度。 为了提高速度，如果不涉及外部资源读取的话，要提高运行速度就要做到并行计算，依赖于处理器的数量；如果需要等待耗时的外部资源读取，就可以通过并发边读边运算。 算法导论有一章节提到...
java多线程—多线程常用操作方法
Devin
03-18 1330
本节目标：1.了解设置和取得线程名称2.了解线程的强制运行3.了解线程的休眠4.了解线程的礼让5.了解线程的中断操作--------------------------------------------------------------------------------多线程常用的操作方法：1.取得和设置线程名称getName()：取得线程名称setName()：设置线程名称线程的名称一般在...
多线程的常用操作方法
weixin_43224539的博客
02-16 149
1.线程的命名与取得 多线程的运行状态往往是不确定的,所以对于多线程操作必须有一个明确标识出线程对象的信息,这个信息就通过线程名称来描述,在Thread类中提供有如下取得线程名称的方法: (1) 创建线程时设置名称的构造方法 public Thread (Runnable target,String name) (2) 设置线程名称的普通方法 public final synchro...
多线程使用方式
qq1105273619的博客
06-30 198
导入模块 import threading import time声明方法 def work(n): 　print(‘{}开始于{}’.format(threading.current_thread().name,time.ctime)) 　time.sleep(n) 　print(‘{}结束于{}’.format(threading.current_thread().name,time
qt多线程的使用方法
最新发布
03-20
Qt是一个跨平台的C++应用程序开发框架，提供了丰富的多线程支持。下面是Qt多线程的使用方法： 1. 继承QThread类：创建一个新的类并继承自QThread类，重写其run()函数，在run()函数中编写需要在新线程中执行的代码。 2. 重写run()函数：在run()函数中编写需要在新线程中执行的代码逻辑。 3. 创建线程对象：在主线程中创建一个新的线程对象。 4. 启动线程：调用线程对象的start()函数来启动线程。 5. 线程间通信：使用Qt提供的信号和槽机制来实现线程间的通信。可以在新线程中通过发射信号的方式将数据传递给主线程，主线程通过连接信号和槽的方式接收数据。 6. 线程同步：使用Qt提供的互斥锁（QMutex）或读写锁（QReadWriteLock）来实现线程间的同步，避免多个线程同时访问共享资源导致的数据竞争问题。 7. 线程结束：在新线程中可以通过调用quit()或exit()函数来结束线程的执行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值