关于java:涨姿势了原来这才是多线程正确实现方式

Java内存模型
涨姿态了!原来这才是多线程正确实现形式
涨姿态了!原来这才是多线程正确实现形式
线程同步
线程同步机制是一套实用于协调线程之间的数据拜访机制,该机制能够保障线程平安

java平台提供的线程同步机制包含:锁、volatile关键字、final关键字,static关键字、以及相干API如object.wait/object.notify

锁概述
线程平安问题的产生前提是多个线程并发访问共享数据,将多个数据对共享数据的并发拜访,转化为串行拜访,即共享数据只能被一个线程拜访,锁就是这种思路。

线程拜访数据时必须先取得锁,取得锁的线程称为锁的持有线程,一个锁一次只能被一个线程持有,持有线程在取得锁之后和开释锁之前锁执行的代码称之为临界区。

锁具备排它性(Exclisive),即一个锁只能被一个线程持有,这种锁称为排它锁或者互斥锁。

涨姿态了!原来这才是多线程正确实现形式
JVM局部把锁分为外部锁和显示锁,外部锁通过Synchronized关键字实现,显示锁通过
java.concurrent.locks.Lock接口实现类实现的。

锁的作用
锁可能实现对共享数据的平安,保障线程的原子性,可见性与有序性。

锁是通过互斥保障原子性,一个锁只能被一个线程持有,这就保障了临界区的代码一次只能被一个线程执行,使得临界区代码所执行的的操作自然而然的具备不可分割的个性,既具备了原子性。

好比一条路段所有车辆都在跑,并发执行,在通过某一个路段的时候,多车道变为一车道,一次只能通过一辆车,由并发执行改为串行执行。

可见性是通过写线程冲刷处理器的缓存和读线程刷新处理器缓存这两个动作,锁的取得隐含着刷新处理器缓存的动作,锁的开释隐含着冲刷处理器缓存的动作。

锁可能保障有序性,写线程在临界区所执行的临界区看来像是齐全依照源码程序执行的。

锁的相干概念
可重入性:一个线程持有该锁的时候可能再次/屡次申请该锁
如果一个线程持有一个锁的时候,还没有开释,但还可能持续胜利申请该锁,称该锁可重入,反之。

锁的争用与调度
java中外部锁属于非偏心锁,显示锁反对非偏心锁和偏心锁

锁的粒度
一个所能够爱护的共享数据的数量大小称为锁的粒度。

锁爱护共享数据量大,称为锁粒度粗,否则称为粒度细。

锁的粒度过粗会导致线程在申请锁时会进行不必要的期待,锁粒度过细会减少锁调度的开销。

比方银行有一个柜台一个员工能够办理开卡、销户、取现、贷款那么所有人都只能去这个柜台办理业务,会须要很长的等待时间。然而如果把业务细分,一个业务一个柜台,这时候减少了银行的开销,须要三个员工。

外部锁:Synchronized
Java中每一个对象都有一个与之关联的外部锁,这种锁也叫监视器,是一种排它锁,能够保障原子性、可见性、排它性。

Synchronized(对象锁)
{
同步代码块,能够在同步代码块中访问共享数据
}
润饰实例办法称为同步实例办法,润饰静态方法称为同步静态方法。

Synchronized同步代码块
public class SynchronizedLock {

public static void main(String[] args) {
    SynchronizedLock synchronizedLock=new SynchronizedLock();
    for (int i = 0; i <2 ; i++) {
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm();
            }
        }.start();
    }
}
public  void  mm()
{
    for (int i = 0; i <100 ; i++) {
        System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
}

}
两个线程的代码都在并发执行

涨姿态了!原来这才是多线程正确实现形式
当初要打印的时候进行同步,同步的原理线程在执行的时候要先要取得锁

public class SynchronizedLock {

public static void main(String[] args) {
    SynchronizedLock synchronizedLock=new SynchronizedLock();
    for (int i = 0; i <2 ; i++) {
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm();//应用锁的对象是synchronizedLock对象
            }
        }.start();
    }
}
public  void  mm()
{
    synchronized (this)//this作为以后对象
    {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

}
涨姿态了!原来这才是多线程正确实现形式
因为Synchronized外部锁是排它锁,一次只能被一个线程持有,当初是Thread-0先获得锁对象,Thread-1在期待区期待Thread-0执行结束开释锁,Thread-1取得锁再执行。

锁对象不同不能实现同步

public class SynchronizedLock {

public static void main(String[] args) {
    SynchronizedLock synchronizedLock=new SynchronizedLock();
    SynchronizedLock synchronizedLock2=new SynchronizedLock();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm();//应用锁的对象是synchronizedLock对象
            }
        }.start();
    new Thread(new RunnableThread())
    {
        @Override
        public void run() {
            synchronizedLock2.mm();//应用锁的对象是synchronizedLock对象
        }
    }.start();
}
public  void  mm()
{
    synchronized (this)//this作为以后对象
    {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

}
涨姿态了!原来这才是多线程正确实现形式
因而想要同步必须应用同一个锁对象

应用常量作为锁对象

public class SynchronizedLock {

public static void main(String[] args) {
    SynchronizedLock synchronizedLock=new SynchronizedLock();
    SynchronizedLock synchronizedLock2=new SynchronizedLock();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm();//应用锁的对象是synchronizedLock对象
            }
        }.start();
    new Thread(new RunnableThread())
    {
        @Override
        public void run() {
            synchronizedLock.mm();//应用锁的对象是synchronizedLock对象
        }
    }.start();
}
public  static  final  Object obj=new Object();
public  void  mm()
{
    synchronized (obj)//常量作为以后对象
    {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

}
同步实例办法
应用synchronized润饰实例办法,同步实例办法,默认应用this作为锁对象

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

    SynchronizedLock synchronizedLock=new SynchronizedLock();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm();
            }
        }.start();
    new Thread(new RunnableThread())
    {
        @Override
        public void run() { 
            synchronizedLock.mm2();
        }
    }.start();
}
//同步实例办法
public  synchronized void  mm()
{
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
}
public  void  mm2()
{
    synchronized (this)//常量作为以后对象
    {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

}
同步静态方法
应用synchronized润饰静态方法,同步静态方法,默认运行时应用SynchronizedLock class作为锁对象

public class SynchronizedLock {

public static void main(String[] args) {
    SynchronizedLock synchronizedLock=new SynchronizedLock();
    new Thread(new RunnableThread())
    {
        @Override
        public void run() {
            synchronizedLock.mm2();
        }
    }.start();
    new Thread(new RunnableThread())
    {
        @Override
        public void run() {
            SynchronizedLock.mm();//应用锁的对象是SynchronizedLock.class
        }
    }.start();
}
//同步静态方法
public  synchronized static void  mm()
{
    for (int i = 0; i <100 ; i++) {
        System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
}
public  void  mm2()
{
    synchronized (SynchronizedLock.class)//常量作为以后对象
    {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

}
同步代码块和同步办法如何抉择
public class SynchronizedLock {

public static void main(String[] args) {
    SynchronizedLock synchronizedLock=new SynchronizedLock();
    new Thread(new RunnableThread())
    {
        @Override
        public void run() {
            try {
                synchronizedLock.mm2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }.start();
    new Thread(new RunnableThread())
    {
        @Override
        public void run() {
            try {
                synchronizedLock.mm2();//应用锁的对象是SynchronizedLock.class
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }.start();
}
//同步实例办法 锁的粒度粗 执行效率低
public  synchronized  void  mm() throws InterruptedException {
    long starttime= System.currentTimeMillis();
    System.out.println("start");
    Thread.sleep(3000);
    for (int i = 0; i <100 ; i++) {
        System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
    System.out.println("end");
    long Endtime= System.currentTimeMillis();
    System.out.println(Endtime-starttime);
}
//同步代码块 锁的粒度细 并发效率高
public  void  mm2() throws InterruptedException {
    System.out.println("start");
    Thread.sleep(3000);
    synchronized (this)//常量作为以后对象
    {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
    System.out.println("end");
}

}
在执行同步办法的时候,两次线程调用每次都须要休眠三秒,而同步代码块同时启动线程都先筹备三秒,效率比拟高

脏读
public class Test06 {

public static void main(String[] args) throws InterruptedException {
    User user=new User();
    SubThread subThread=new SubThread(user);
    subThread.start();
    user.GetName();
}
static  class SubThread extends Thread
{
    public User user;

    public SubThread(User user)
    {
        this.user=user;
    }

    @Override
    public void run() {
        user.SetValue("ww","456");
    }
}
static  class  User
{
    private  String name="ylc";
    private  String pwd="123";
    public  void  GetName()
    {
        System.out.println(Thread.currentThread().getName()+"==>"+name+"明码"+pwd);
    }
    public  void  SetValue(String name,String pwd)
    {
        System.out.println("原来为为name="+this.name+",pwd="+this.pwd);
        this.name=name;
        this.pwd=pwd;
        System.out.println("更新为name="+name+",pwd="+pwd);
    }

}

}
涨姿态了!原来这才是多线程正确实现形式
在批改数据还没有实现的时候,就读取到了原来的数据,而不是批改之后的

呈现脏读的起因是对共享数据的批改和读取不同步引起的

解决办法是对批改和读取的办法进行同步办法上加上synchronized关键字

涨姿态了!原来这才是多线程正确实现形式
线程出现异常开释锁
如果在同步办法中,一个线程呈现了异样,会不会没有开释锁,其余在期待的线程就在始终期待,论证:

public class SynchronizedLock {

public static void main(String[] args) {
    SynchronizedLock synchronizedLock=new SynchronizedLock();
    new Thread(new RunnableThread())
    {
        @Override
        public void run() {
            synchronizedLock.mm();
        }
    }.start();
    new Thread(new RunnableThread())
    {
        @Override
        public void run() {
            synchronizedLock.mm2();
        }
    }.start();
}
//同步实例办法
public  synchronized void  mm()
{
    for (int i = 0; i <100 ; i++) {
        if(i==50)
        {
            Integer.parseInt("abc");//异样设置
        }
        System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
}
public  void  mm2()
{
    synchronized (this)
    {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

}
涨姿态了!原来这才是多线程正确实现形式
同步过程中线程出现异常,会主动开释锁对象,以供下一个线程继续执行

死锁
多线程中可能须要应用多个锁,如果获取锁的程序不统一,可能导致死锁。

public class Text06_5 {

public static void main(String[] args) {
    SubThread subThread=new SubThread();
    SubThread subThread2=new SubThread();
    subThread.setName("a"); subThread2.setName("b");
    subThread.start();subThread2.start();
}
static  class SubThread  extends  Thread
{
    private  static  final Object lock1=new Object();
    private  static  final Object lock2=new Object();

    @Override
    public void run() {
        if("a".equals(Thread.currentThread().getName()))
        {
            synchronized (lock1)
            {
                System.out.println("a 线程 lock1取得了锁,再须要取得lock2");
                synchronized (lock2)
                {
                    System.out.println("a 线程 lock2取得了锁");
                }
            }
        }

        if("b".equals(Thread.currentThread().getName()))
        {
            synchronized (lock2)
            {
                System.out.println("b 线程 lock2取得了锁,再须要取得lock1");
                synchronized (lock1)
                {
                    System.out.println(" b 线程 lock1取得了锁");
                }
            }
        }
    }
}

}
涨姿态了!原来这才是多线程正确实现形式
程序还在运行,却进入了卡死状态,a线程失去了lock1,要想把该线程开释的执行上面的代码获取lock2,而lock2被b线程获取无奈开释,呈现了鹬蚌相争的状况。

防止死锁:当须要取得锁时,所有线程取得锁的程序统一,a线程先锁lock1,再锁lock2,b线程同理,就不会呈现死锁了。

【腾讯云】云产品限时秒杀,爆款1核2G云服务器,首年50元

阿里云限时活动-2核2G-5M带宽-60G SSD-1000G月流量 ,特惠价99元/年(原价1234.2元/年,可以直接买3年),速抢

本文由乐趣区整理发布,转载请注明出处,谢谢。

您可能还喜欢...

发表评论

您的电子邮箱地址不会被公开。

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据