线程同步synchronized,Class与Object

synchronized (class):class类的同步,同步的时候会同步整个class

synchronized (Object):Object的同步,只对其中的对象同步

如下:对类B中的同步代码块的同步,对比之后放可明白

synchronized (MyThread.class)

例:

A:类UnsafeSequence

public class UnsafeSequence {
    private static int value;
    
    public int getValue()
    {
        synchronized (UnsafeSequence.class) {
            return value++;
        }
    }
    
    public int getValueA()
    {
        synchronized (this) {
            return value++;
        }
    }
}

B:类MyThread

public class MyThread implements Runnable {
    private UnsafeSequence unsafe;
    private static int value;
    
    @Override
    public void run() {
        unsafe = new UnsafeSequence();
        for(int i = 0; i < 60; i++)
        {
            synchronized (MyThread.class) {
                System.out.println(Thread.currentThread().getName() + "----in:");
                System.out.println(Thread.currentThread().getName() + " thread run i = " + i + ";value = " + unsafe.getValue());
                System.out.println(Thread.currentThread().getName() + "----out:" + value++);
            }
        }
    }

}

C:主函数

public class TestMain {
    public static void main(String[] args) {
        MyThread target_1 = new MyThread();
        MyThread target_2 = new MyThread();
        Thread thread_1 = new Thread(target_1, "A");
        Thread thread_2 = new Thread(target_2, "B");
        thread_1.start();
        thread_2.start();
    }
}

结果如下:

B----in:
B thread run i = 0;value = 0
B----out:0
B----in:
B thread run i = 1;value = 1
B----out:1
B----in:
B thread run i = 2;value = 2
B----out:2

去掉B中的同步,或换为Object,结果如下:

A----in:
B----in:
A thread run i = 0;value = 0
B thread run i = 0;value = 1
A----out:0
B----out:1
A----in:
B----in:
A thread run i = 1;value = 2
B thread run i = 1;value = 3
B----out:3
B----in:
A----out:2

时间: 2024-10-14 22:56:36

线程同步synchronized,Class与Object的相关文章

Java线程(二):线程同步synchronized和volatile

上篇通过一个简单的例子说明了线程安全与不安全,在例子中不安全的情况下输出的结果恰好是逐个递增的(其实是巧合,多运行几次,会产生不同的输出结果),为什么会产生这样的结果呢,因为建立的Count对象是线程共享的,一个线程改变了其成员变量num值,下一个线程正巧读到了修改后的num,所以会递增输出. 要说明线程同步问题首先要说明Java线程的两个特性,可见性和有序性.多个线程之间是不能直接传递数据交互的,它们之间的交互只能通过共享变量来实现.拿上篇博文中的例子来说明,在多个线程之间共享了Count类的

多线程 Thread 线程同步 synchronized

1.多线程基础以及两种启用方式 /** * 多线程 * 多线程改变了代码的执行方式,从原有的所有代码都串行操作改变为多个代码片段之间并行操作. * 因此多线程允许多个代码片段"同时运行". * * 创建线程的方式有两种 * 1:继承线程并重写run方法,在run方法中定义线程要执行的任务. */ public class ThreadDemo1 { public static void main(String[] args) { Thread t1 = new MyThread1();

java线程同步-synchronized

什么是"线程同步" ? 所谓线程同步就是若干个线程都需要使用一个 synchronized(同步)修饰的方法,当一个线程使用synchronized方法时,其他线程想使用这个synchronized方法时就必须等待,直到这个线程使用完该 synchronized 方法. 在下面的例子中有两个线程,会计和出纳,他俩共同拥有一个账本,她俩都可以使用saveOrTake(int amount)方法对账本进行访问,会计使用saveOrTake(int mount)方法时,向账本上写入存钱记录:

三、线程同步Synchronized

参考:https://blog.csdn.net/zjy15203167987/article/details/82531772 https://blog.csdn.net/luoweifu/article/details/46613015 一.并发 同一个对象多个线程同时操作 原文地址:https://www.cnblogs.com/qiaoxin11/p/12628660.html

Java之线程,常用方法,线程同步,死锁

1, 线程的概念 进程与线程 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程.(进程是资源分配的最小单位) 线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小.(线程是cpu调度的最小单位) 切换而不是同步 一个程序中的方法有几条执行路径, 就有几个线程 Java中线程的生命周期 Java线程具有五中基本状态 新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t =

线程同步初解---转载

//线程安全问题的原因其实就是:线程执行多条语句的时候出现了阻塞,然后没有执行完该线程另一线程就启动了. //解决方法就是同步代码块:synchronized(对象) //synchronized(对象) //{ //  需要同步的代码 //} class Ticket implements Runnable { private int ticket = 100; Object obj = new Object(); public void run() { while(true) { synch

Java基础教程——线程同步

线程同步 synchronized:同步的 例:取钱 不做线程同步的场合,假设骗子和户主同时取钱,可能出现这种情况: [骗子]取款2000:账户余额1000 [户主]取款2000:账户余额1000 结果是社会财富增加1000,银行不开心. 代码如下所示: // 账户类 class Account { private int accountBalance = 2000; public void withdraw(String userName, int amount) { System.out.p

java线程同步: synchronized详解(转)

Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码. 一.当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行(如果多个线程调用同一个线程,只能有一个线程得到执行).另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块. 二.然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中

java的线程同步机制synchronized关键字的理解

线程同步:               由于同一进程的多个线程共享同一片存储空间,在带来方便的同时,也带来了访问冲突这个严重的问题.Java语言提供了专门机制以解决这种冲突,有效避免了同一个数据对象被多个线程同时访问. 需要明确的几个问题: 1)synchronized关键字可以作为函数的修饰符,也可作为函数内的语句,也就是平时说的同步方法和同步语句块.如果 再细的分类,synchronized可作用于instance变量.object reference(对象引用).static函数和clas