Java多线程(3)

Java内存模型

并发编程的问题

为了保证数据的安全，需要满足以下三个特性：

原子性是指在一个操作中就是cpu不可以在中途暂停然后再调度，既不被中断操作，要不执行完成，要不就不执行。
可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
有序性即程序执行的顺序按照代码的先后顺序执行。

为了保证共享内存的正确性（可见性、有序性、原子性），内存模型定义了共享内存系统中多线程程序读写操作行为的规范。通过这些规则来规范对内存的读写操作，从而保证指令执行的正确性。它与处理器有关、与缓存有关、与并发有关、与编译器也有关。他解决了CPU多级缓存、处理器优化、指令重排等导致的内存访问问题，保证了并发场景下的一致性、原子性和有序性。

Java内存模型（Java Memory Model ,JMM）就是一种符合内存模型规范的，屏蔽了各种硬件和操作系统的访问差异的，保证了Java程序在各种平台下对内存的访问都能保证效果一致的机制及规范。

Java内存模型规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存，线程的工作内存中保存了该线程中是用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存。不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量的传递均需要自己的工作内存和主存之间进行数据同步进行。

而JMM就作用于工作内存和主存之间数据同步过程。他规定了如何做数据同步以及什么时候做数据同步。

synchronize

synchronize是Java提供的一种原子性内置锁，Java中的每个对象都可以把它当做一个同步锁来使用

synchronized主要的作用：

保证在同一时刻，只有一个线程可以执行某个方法或某个代码块（原子性），同时synchronized可以保证一个线程的变化可见（可见性）

synchronize同步方法

方法内的变量时线程安全的

非线程安全的问题存在于实例变量中，如果是方法内部的私有变量，则不存在这个问题

例子:


public class SelfPrivateNum {

    public void add(String name){
        try {
            int num = 0;
            if (name.equals("a")){
                num = 100;
                System.out.println("a set over");
                Thread.sleep(3000);
            } else {
                num = 200;
                System.out.println("b set over");
            }
            System.out.println(name + "  " +num);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class ThreadA extends Thread{

    private SelfPrivateNum selfPrivateNum;

    public ThreadA(SelfPrivateNum selfPrivateNum) {
        this.selfPrivateNum = selfPrivateNum;
    }

    @Override
    public void run() {
        selfPrivateNum.add("a");
    }
}

public class ThreadB extends Thread{

    private SelfPrivateNum selfPrivateNum;

    public ThreadB(SelfPrivateNum selfPrivateNum) {
        this.selfPrivateNum = selfPrivateNum;
    }

    @Override
    public void run() {
        selfPrivateNum.add("b");
    }
}




public class Run {

    public static void main(String[] args) {

        SelfPrivateNum selfPrivateNum = new SelfPrivateNum();

        ThreadA a = new ThreadA(selfPrivateNum);

        a.start();

        ThreadB b = new ThreadB(selfPrivateNum);

        b.start();

    }
}

实例变量非线程安全

如果出现多个线程方法一个对象中的实例变量，则可能出现线程不安全的问题

比如下面对象仅有一个实例变量，则可能出现覆盖的情况

public class SelfPrivateNum {

    private int num = 0;
    public void add(String name){
        try {
            if (name.equals("a")){


                num = 100;
                System.out.println("a set over");
                Thread.sleep(3000);
            } else {


                num = 200;
                System.out.println("b set over");
            }
            System.out.println(name + "  " +num);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class ThreadA extends Thread{

    private SelfPrivateNum selfPrivateNum;

    public ThreadA(SelfPrivateNum selfPrivateNum) {
        this.selfPrivateNum = selfPrivateNum;
    }

    @Override
    public void run() {
        selfPrivateNum.add("a");
    }
}


public class ThreadB extends Thread{

    private SelfPrivateNum selfPrivateNum;

    public ThreadB(SelfPrivateNum selfPrivateNum) {
        this.selfPrivateNum = selfPrivateNum;
    }

    @Override
    public void run() {
        selfPrivateNum.add("b");
    }
}



public class Run {

    public static void main(String[] args) {

        SelfPrivateNum selfPrivateNum = new SelfPrivateNum();

        ThreadA a = new ThreadA(selfPrivateNum);

        a.start();

        ThreadB b = new ThreadB(selfPrivateNum);

        b.start();

    }
}

接下来就可以使用synchronize关键字了

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
1. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
1. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
1. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

synchronize修饰代码块

public class T1 {


//    一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。

    
    public static void main(String[] args) {
        System.out.println("使用关键字synchronized");
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "SyncThread1");
        Thread thread2 = new Thread(syncThread, "SyncThread2");
        thread1.start();
        thread2.start();
    }
}
class SyncThread implements Runnable {
    private static int count;
    public SyncThread() {
        count = 0;
    }
    public  void run() {
        synchronized (this){
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println("线程名:"+Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public int getCount() {
        return count;
    }

}

输出:

使用关键字synchronized
线程名:SyncThread1:0
线程名:SyncThread1:1
线程名:SyncThread1:2
线程名:SyncThread1:3
线程名:SyncThread1:4
线程名:SyncThread2:5
线程名:SyncThread2:6
线程名:SyncThread2:7
线程名:SyncThread2:8
线程名:SyncThread2:

当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。

但如果使用两个不同的对象呢？

public class T2 {

    //    一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。


    public static void main(String[] args) {
        System.out.println("使用关键字synchronized");
//        SyncThread syncThread = new SyncThread();
        
//        这边创建了两个不同的SyncThread_1对象
        Thread thread1 = new Thread(new SyncThread_1(), "SyncThread1");
        Thread thread2 = new Thread(new SyncThread_1(), "SyncThread2");
        thread1.start();
        thread2.start();
    }
}
class SyncThread_1 implements Runnable {
    private static int count;
    public SyncThread_1() {
        count = 0;
    }
    public  void run() {
        synchronized (this){
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println("线程名:"+Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public int getCount() {
        return count;
    }
    
}

这时创建了两个SyncThread的对象syncThread1和syncThread2，线程thread1执行的是syncThread1对象中的synchronized代码(run)，而线程thread2执行的是syncThread2对象中的synchronized代码(run)；我们知道synchronized锁定的是对象，这时会有两把锁分别锁定syncThread1对象和syncThread2对象，

而这两把锁是互不干扰的，不形成互斥，所以两个线程可以同时执行。

当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块

public class T3 {


//    当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。

    
    public static void main(String[] args) {
        System.out.println("使用关键字synchronized");
        Mthreads mt=new Mthreads();
        Thread thread1 = new Thread(mt, "mt1");
        Thread thread2 = new Thread(mt, "mt2");
        thread1.start();
        thread2.start();
    }


}

class Mthreads implements Runnable {
    private int count;

    public Mthreads() {
        count = 0;
    }

    public void countAdd() {
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //非synchronized代码块，未对count进行读写操作，所以可以不用synchronized
    public void printCount() {
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println(Thread.currentThread().getName() + " count:" + count);
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.equals("mt1")) {
            countAdd();
        } else if (threadName.equals("mt2")) {
            printCount();
        }
    }
}

synchronize修饰方法

Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，

public synchronized void method(){};

synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数

public class T4 {

    public static void main(String[] args) {

        System.out.println("使用关键字synchronized");
        SyncThread_2 syncThread = new SyncThread_2();
        Thread thread1 = new Thread(syncThread, "SyncThread1");
        Thread thread2 = new Thread(syncThread, "SyncThread2");
        thread1.start();
        thread2.start();

    }
}


class SyncThread_2 implements Runnable {
    private static int count;
    public SyncThread_2() {
        count = 0;
    }
    public  void run() {
        synchronized (this){
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println("线程名:"+Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public int getCount() {
        return count;
    }

}

用synchronized修饰方法的注意点:

1. synchronized关键字不能继承

虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。

如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加synchronized关键字才可以

当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了

这两种方式的例子代码如下：

在子类方法中加上synchronized关键字

public class Base {

    public synchronized void method(){
        
    }
}


public class SubClass extends Base{

    @Override
    public synchronized void method() {
        super.method();
    }
}

在定义接口方法时不能使用synchronized关键字。

构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

synchronize修饰静态方法

静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象

public class T1 {

    
    public static void main(String[] args) {
        System.out.println("使用关键字静态synchronized");
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "SyncThread1");
        Thread thread2 = new Thread(syncThread, "SyncThread2");
        thread1.start();
        thread2.start();
    }
}


class SyncThread implements Runnable {
    private static int count;

    public SyncThread() {
        count = 0;
    }

    public synchronized static void method() {
        for (int i = 0; i < 5; i ++) {
            try {
                System.out.println(Thread.currentThread().getName() + ":" + (count++));
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void run() {
        method();
    }
}

syncThread1和syncThread2是SyncThread的两个对象，但在thread1和thread2并发执行时却保持了线程同步。

这是因为run中调用了静态方法method，而静态方法是属于类的，所以syncThread1和syncThread2相当于用了同一把锁。这与使用关键字synchronized运行结果相同

synchronize修饰类

public class T2 {
    public static void main(String[] args) {
        System.out.println("使用ClassName");
        SyncThread_1 syncThread = new SyncThread_1();
        Thread thread1 = new Thread(syncThread, "SyncThread1");
        Thread thread2 = new Thread(syncThread, "SyncThread2");
        thread1.start();
        thread2.start();
    }
}


class ClassName {
    public void method() {
        synchronized(ClassName.class) {

        }
    }
}


class SyncThread_1 implements Runnable {
    private static int count;

    public SyncThread_1() {
        count = 0;
    }

    public static void method() {
        synchronized(SyncThread_1.class) {
            for (int i = 0; i < 5; i ++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public synchronized void run() {
        method();
    }
}

无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制

String作为对象锁可能带来的问题

因为在JVM中String具有常量池缓存的功能，所以可能出现下列问题:

public class Service {

    public static void print(String param){

        try {
            synchronized (param){
                while (true){
                    System.out.println(Thread.currentThread().getName());
                    Thread.sleep(1000);
                }
            }
        } catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class AThread extends Thread{

    private Service service;

    public AThread(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.print("AA");
    }
}


public class BThread extends Thread{

    private Service service;

    public BThread(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.print("AA");
    }
}


public class Run {

    public static void main(String[] args) {

        Service service = new Service();

        AThread aThread = new AThread(service);

        aThread.setName("A");

        aThread.start();

        BThread bThread = new BThread(service);

        bThread.setName("B");

        bThread.start();


    }
}

结果陷入死循环，一直输出A

就是由于String的两个值都是"AA"，因为缓存的关系，这两个是同一个对象，也就是两个线程持有的是同一把锁，所以线程B执行不了

Coder_py

发布了189 篇原创文章 · 获赞 58 · 访问量 18万+

私信关注

Java多线程(3)

Java多线程(3)

Java内存模型

并发编程的问题

synchronize

synchronize同步方法

方法内的变量时线程安全的

实例变量非线程安全

synchronize修饰代码块

当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块

synchronize修饰方法

synchronize修饰静态方法

synchronize修饰类

String作为对象锁可能带来的问题

猜你喜欢