Java高并发——线程基础

1.什么是线程

同一个时间段内,不同的任务模块可以并发进行,称为线程,是CPU的最小调度单位。
进程和线程的区别:
从资源分配的角度:
进程是资源分配的最小单位,一个进程的多个线程共享进程的资源。
从cpu调度的角度:
所有的程序都是以进程的形式运行在操作系统上,接受操作系统的资源分配,其中就包括CPU分配。
进程在执行的时候,会开辟多条线程,来处理不同类型的任务,CPU通过在线程上的调度实现进程间的调度。
从包含关系上:
进程包含线程,进程至少包含一条线程,线程最多属于一个进程。
进程切换和线程切换的成本也不同:
线程切换是不涉及虚拟地址空间的变化,而进程的切换需要改变虚拟的地址空间,操作系统本身会将不用的进程的一些依赖移除内存空间,给其他的应用程序让路。导致再切换到这个进程的时候,会发生很多的缺页错误,就是我调用的方法在内存中找不到,需要重新导入,这样的切换成本就很大了。
CPU按照一定的方法在线程之间切换,比如可以用condition的await和signal方法进行线程调度,也可以利用线程池来进行调度。按照一定的时间,或者是争抢资源的方式或者是ForkJoin的方式等。

并行和并发的区别

parallel是并行,concurrent是并发
在单处理器系统上,只可能存在并发,因为并行要求同一时间点,两个进程或线程分配到不同的cpu上执行,因而不争抢CPU资源。
并发是说多个线程或进程共享同一个时间段,在同一个CPU上,将cpu的运行时间分成若干时间片,一个时间片内只能有一个线程在执行。
比如开了100个消费者线程,设备是四核八线程的(四个物理核心,8个逻辑处理器(相当于一个人的左右手))java自动获取的Runtime.getRuntime().availableProcessors()是逻辑处理器的个数。
所以相当于100个消费者线程将在8个逻辑处理器上运行,那么同一时间在不同处理器上运行的是并行状态,而在同一个处理器上运行的,只能是并发状态。因为一个处理器同一时间只能执行一项任务。

2.如何开启一个新的线程

(1)写一个类继承Thread类
(2)写一个类实现Runnable接口,然后实例一个对象,new一个thread,调用start方法。

3.基本的线程同步——synchronized关键字

从synchronized关键字来说,锁定一个对象,当对象在执行一个同步代码块时,其他线程必须要等待该线程执行完毕释放对象的锁,其他的线程才能执行此代码块,保证了操作的原子性。线程执行完毕之后会将CPU缓存区的数据更新到主存。保证了可见性。

synchronized的几个用法

(1)锁定一个对象,或this对象

private Object oo=new Object();//堆内存里的一个引用
//synchronized的互斥性
sycnhronized(oo){
    //要执行synchronized里面的代码,必须先申请拿到oo的锁。
    //如果没有其他线程在执行,就可以成功拿到锁
    //如果有其他线程正在执行同一段代码,这段线程只能在synchronized处等待oo锁的释放。然后拿到锁,再执行这段代码。

}
synchronized(this){
     //用this来代替oo对象
    //如果要执行这段代码,必须要等待this锁的释放。类似于厕所的门,锁住厕所自身。
}

(2)直接把synchronized放在方法的声明处

public synchronized void m(){
    //这里synchronized锁定的也是this对象。
    //如果新建其他的对象,来调用sychronized方法,其实是锁不住的。
}

(3)如果synchronized应用在一个静态方法上

public synchronized static void m(){
    //因为静态方法是不需要对象来调用的,所以不能使用this关键字
    //这种方法就和下面的synchronized(T.class)是一样的,使用反射的机制,获取了当前类的class对象
}
public static void m(){
    synchronized(T.class){
        //因为synchronized本质上是对对象上锁,用一个实例对象来调用方法,只有等对象的锁释放之后,其他的线程才能执行。
        //和上面方法性质相同
    }
}

(4)同步方法和非同步方法是否能同时执行:能,互不影响

public synchronized void m1(){
    //同步方法执行过程中需要锁定当前对象
}
public void m2(){
    //非同步方法执行过程中不需要锁定当前对象
}
T t=new T();
new Thread(()->t.m1()).start();
new Thread(()->t.m2()).start();//如果再有一个线程调用m1方法,就需要等待锁的释放,而新的线程去调用互不影响的m2方法,就不需要等待锁的释放。
//线程1的执行过程中,线程2 是可以执行的。

(5)写入加锁,但读取不加锁,容易产生脏读

public synchronized void write(){
    //某些操作中对写入的方法加锁
}
public String READ(){
    return getSomething;
    //对读取的方法没有加锁,容易产生脏读,读的过程中,write还没有执行完,并没有最终写入的值。
    //因为非同步方法是随时都可以执行的
    //所以对于两个线程共享内存资源的时候,必须进行线程同步,读写都可以。
}

脏读可以用CopyOnWrite容器来实现。
写时复制容器,写的效率低,读的效率高。
写入时复制就是,对于要访问同一个内存的线程,如果不改变内存的值,那就直接一个指针指向这个内存地址,如果要修改这个内存的值,就copy一份副本给需要修改的调用者。修改的时候,有线程正在读取数据会读修改之前的数据,修改之后会立即改变引用,指向改变之后的容器。
当写入少,而读取多的时候适合用这个容器。
(6)同步方法调用另一个同步方法——重入锁

public synchronized void m1(){
    //同步方法可以调用同步方法,synchronized本身是支持重入锁的。
    //在执行m1的时候已经获得了对象的锁,调用同步方法m2,仍然是需要申请锁。
    //因为是同一个线程内,synchronized锁是可以重入的,所以m2在可以执行。
    m2();
}
public synchronized void m2(){
    //同步方法m2
}

(7)子类调用父类的同步方法

public class T{
    public synchronized void m(){
        //
    }
    public static void main(String[] args){
        new TT().m();
        //new子类对象之前必须要new一个父类对象,但是synchronized锁定的是this对象也就是new TT()
    }
}
public class TT extends T{
    @Override
    public synchronized void m(){
        super.m();
    }
}

(8)synchronized的优化
1)synchronized代码段越少越好,采用细粒度锁
2)避免改变sychronized锁住的对象的引用,改变了引用就锁不住了。
3)尽量不要锁定字符串常量

String s1="hello";
    String s2="hello";
    //实际上,s1s2指向常量池中的同一个内存,如果要锁定他们,实际锁定的是一个对象,可能产生死锁。

java锁只能锁住堆里的对象。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值