栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

javase 多线程

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

javase 多线程

文章目录
  • 相关概念
  • Thread类的有关方法
  • 线程的创建和使用
    • 1.继承于Thread类
    • 2.实现Runnable接口
    • 3.实现Callable接口
    • 4.使用线程池(重点)
  • 线程的同步
    • 1.同步代码块
    • 2.同步方法
    • 3.Lock锁(JDK5)
  • 死锁
  • 线程优先级
  • 线程的生命周期
  • 单例模式(线程安全的懒汉式)
  • 线程的通信

相关概念

程序——一段静态的代码,静态对象
进程——正在运行的程序,动态的过程,资源分配的单位,系统为每个进程分配不同的内存区域
线程——是一个进程细化内部的一条执行路径;一个进程同一时间并行执行多个线程,即支持多线程;
作为调度和执行的单位,拥有独立的运行栈和pc;多个线程共享同一个进程中的方法区和堆
分类:守护线程、用户线程 守护线程服务于用户线程
并行——多个CPU同时执行多个任务
并发——一个CPU同时执行多个任务
多线程的优点:①提高应用程序的相应 ②提高计算机CPU的利用率 ③改善程序结构

Thread类的有关方法

① void start() :1.启动当前线程 2.调用当前线程的run()
② run() : 重写此方法,声明此线程要执行的操作
③ String getName()
④ void setName(String Name)
⑤ static Thread currentThread() :返回执行当前代码的线程
⑥ static void yield() :释放当前CPU的执行权
⑦ join() :在线程a中调用线程b的join方法,则a进入阻塞状态直至b完全执行
⑧ static void sleep(long millis) :阻塞指定毫秒
⑨ stop() :deprecated 强制结束生命周期
⑩ boolean isAlive() :deprecated

线程的创建和使用 1.继承于Thread类

①创建一个继承于Thread的子类
②重写Thread类的run() 【声明此线程要执行的操作】
③创建Thread类的子类的对象 【多个线程多次new】
④通过此对象调用start() 【1.启动当前线程 2.调用当前线程的run()】 【若只调用run(),没有启动线程】
例:
class MyThread1 extends Thread { @override }

MyThread1 t1 = new MyThread1();

t1.setName(“线程1”);
t1.start();//区分调用run()

⑤子类的对象只能调用一次start
⑥采用匿名子类匿名对象的方法
new Thread(){ @override }.start();

2.实现Runnable接口

①创建一个实现了Runnable的类
②实现类去实现Runnable中的抽象方法run() 【声明此线程要执行的操作】
③创建实现类的对象【只new一次】
④将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象 【多个线程多次new】
⑤通过Thread类的对象调用start()
例:
class MyThread2 implements Runnable { @override }

MyThread2 myThread2 = new MyThread2();
Thread t2 = new Thread(myThread2);
t2.start();

⑥子类的对象只能调用一次start
⑦采用匿名子类匿名对象的方法
new Thread(new Runnable(){ @override }).start();

比较:方式1有单继承的局限性,方式2更适合处理多个线程共享数据的情况
Thread类本就实现Runnable接口

JDK5新增线程创建方法(jdk5.0)

3.实现Callable接口

与Runnable相比:
①重写call()方法,可以抛出异常,可以有返回值,支持泛型的返回值;
②需要借助FutureTask类,比如获取返回结果

创建步骤:
①创建实现类 class A implements Callable{}
②重写方法 public Object call() throws Exception{} 【声明此线程要执行的操作】
③创建实现类A的对象 A a = new A();
④借助FutureTask类的构造器创建对象 FutureTask futureTask = new FutureTask(a);
⑤创建Thread的对象 Thread t1 = new Thread(futureTask);
⑥创建完成,可以调用Thread类的方法(start等)
⑦若需要,可以调用futureTask.get()可以返回实现类重写后call()的返回值
例:
class MyThread3 implements Callable { @override }
MyThread3 myThread3 = new MyThread3();
FutureTask futureTask = new FutureTask(myThread3);
Thread t3 = new Thread(futureTask); //还是借助Thread的构造器

t3.start();
Object o = futureTask.get();

4.使用线程池(重点)

好处:①提高响应速度 ②降低资源消耗 ③便于资源管理
说明:
ExecutorService: 线程池接口
ThreadPoolExecutor:实现ExecutorService接口的实现类
Executors:工具类 ,用于创建并返回不同类型的线程池

1.提供指定线程数的线程池
ExecutorService service = Executors.newFixedThreadPool(nThreads);
2.执行指定的线程的操作,需要提供一个实现Runnable或Callable的实现类的对象
service.execute( new Thread1() ); //适用于实现Runnable
service.submit( new Thread2());
3.关闭线程池
service.shutdown();
4.可以设置线程池的属性
service.getClass()
ThreadPoolExecutor service1 = (ThreadPoolExecutor)service; //要调用实现类的对象的方法
service1.setCorePoolSize();
5.开发应用待补充

线程的同步

解决多线程的安全问题
共享数据:多个线程共同操作的变量

1.同步代码块

关键字synchronized
synchronized (同步监视器){ //需要被同步的代码,即操作共享数据的代码 }

同步监视器:同步锁,可以是任一个类的对象。多个线程必须要用同一个锁
①用implements方式实现可以考虑用this(前提是当前类只new一次)
②继承Thread方式可以考虑用“类名.class”(反射),慎用this

2.同步方法

如果操作共享数据的代码都声明在一个方法内,则将此方法声明为synchronized

非静态的同步方法:public synchrod void method(){ } //默认同步监视器:this
静态的同步方式:public static synchrod void method(){ } //默认同步监视器:“类名.class”【没有对象】

3.Lock锁(JDK5)

private ReentrantLock lock = new ReentrantLock();
lock.lock();
lock.unlock();
Lock 和 synchronized 的区别
synchronized方式在执行完同步代码后自动释放同步监视器,而Lock需要手动启动同步"lock()“和结束同步"unlock()”,Lock方式在声明位置上更灵活

死锁

不同线程分别占用了对方需要的同步资源不放弃,都在等待对方放弃【互相拿了对方的锁】
不会出现异常和提示,所有线程都处于阻塞状态

线程优先级

同优先级线程先入先出,采用时间片策略
高优先级,采用抢占式策略,抢占CPU的执行权,但并不意味着只有高优先级线程执行完才到低优先级线程(概率)
MAX/MIN/NORM_PRIORITY = 10/1/5
getPriority()
setPriority(int newPriority)

线程的生命周期

新建—就绪—运行—阻塞—死亡

单例模式(线程安全的懒汉式)
class Bank {
    private Bank() {//提供私有的无参构造器
    }
    
    private static Bank instance = null;//实例化,但不初始化;若此时实例化则为饿汉式

    public static Bank getInstance() {//也可以用synchronized方法 默认锁:Bank.class

        if (instance == null) {//提高效率
            synchronized (Bank.class) {//同步代码块
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}
线程的通信

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

说明:
1.wait(),notify(),notifyAll()都必须使用在同步代码块或同步方法中【lock不可用】
2.上述3个方法的调用者必须是同步代码块或同步方法中的同步监视器
3.上述3个方法是定义在java.lang.Object中的

sleep()和wait()
相同:执行会使当前线程进入阻塞状态
不同:
①声明的位置不一样【sleep()在Thread、wait()在Object】
②调用的要求不一样【sleep()可以在任何需要的场景、wait()必须使用在同步代码块或同步方法中】
③若都使用在同步代码块或同步方法中,是否释放同步监视器【sleep()no、wait()yes】

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/937399.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号