synchronized

synchronized使用之基本原则： synchronized可以锁方法，也可以锁代码片段，但要实现互斥的基本就是在想要互斥的代码上加”同一把锁“，也就是同一个对象，也就是用==判断等于true的对象 下面看一个例子： Work.java 真正做事情的类 1 package com.yzl; 2 3 public class Work { 4 /** 5 * 未同步的 6 * @param name 7 */ 8 public void noSynwrite(String name){ 9 for(int i=0; i<name.length(); i++){ 10 System.out.print(name.charAt(i)); 11 if(i == (name.length()-1)){ 12 System.out.print("\n"); 13 } 14 } 15 } 16 17 /** 18 * 使用同步块，并使用Work的实例对象做为锁 19 * 此方法的同步需保证是调用该方法的work对象是同一个 20 * @param name 21 */ 22 public void write1(String name){ 23 synchronized (this) { 24 for(int i=0; i<name.length(); i++){ 25 System

线程互斥是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。 /** * 线程间的互斥 * @author MrRock * */ public class TraditionalThreadSynchronized { public static void main(String[] args) { new TraditionalThreadSynchronized().init(); } void init(){ final Outputer out = new Outputer(); //线程1 new Thread(new Runnable(){ @Override public void run() { while(true){ try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } out.output1("Tmethod--->AAAAAA"); } } }).start(); //线程2 new Thread(new Runnable(){ @Override public void run() { while(true){ try { Thread.sleep(200); } catch

为什么要使用关键字synchronized? java程序中可以存在多个线程，但是当多个线程操作同一资源时候，可能会导致数据不一致。 区分synchronized方法与synchronized块： synchronized方法 是一种粗粒度的并发控制，某一时刻，只能有一个线程执行该synchronized方法； ‍ ‍ ‍ synchronized块 ‍ ‍ 则是一种细粒度的并发控制，只会将块中的代码同步，位于方法内、synchronized块之外的其他代码是可以被多个线程同时访问到的。 ‍ 线程同步？ 所谓线程同步就是若干个线程都需要使用一个synchronized（同步）修饰的方法，即程序中的若干个线程都需要使用一个方法，而这个方法用synchronized给予修饰，那么多个线程调用该方法时候必须遵守同步机制： 当一个线程A使用synchronized方法时，其他线程想使用这个synchronized方法就必须等待，直至先后才能A使用完毕。即对于synchronized修饰的方法，一次只允许一个线程访问，其他线程只能等待。 2.1 首先看看synchronized方法： public synchronized void saveOrTake(int amount){ // 这里是同步方法 } public void saveOrTake(int amount){

synchronized锁升级的过程 在了解锁升级过程中我们还要知道Java对象的结构 Java对象由 对象头 , 实例数据 , 填充数据 组成，我们这里主要关注对象头。 markWord对象头 对象头里的数据主要是一些运行时数据。 对象头的结构入下图 我这里使用了jol工具进行打印，这里我打印了一个空对象的对象头信息 我们来稍微分析一下，首先我们得知道这几行的含义 OFFSET：偏移量 SIZE：大小（字节） TYPE DESCRIPTION：类型说明 VALUE：具体的数据值 这里前12个字节都是markword，而最后4个字节是用来进行对齐的，关于为什么要对齐这里又要扯到缓存一致性协议上，我们这里暂时先忽略最后四个字节，只看前面的12个字节 这里稍微提一下，在32位的机器上对象头是占用8个byte，而64位机器上占用16个byte。 为了证明我不是瞎扯淡这里我把hotspot的注释贴一下 // The markWord describes the header of an object. // // Bit-format of an object header (most significant first, big endian layout below): // // 32 bits: // -------- // hash:25 ------------>| age:4

初识synchronized 线程安全问题 什么是synchronized synchronized几种使用方式 synchronized特性 线程安全问题 首先得知道什么是线程安全问题 这里我们打个比方 在同一个时间段我们使用两个线程对同一个数据进行++操作，这个被操作数据就可能会出现线程安全问题，假如说这个数据是0，两个线程同时++，我们想要得到的数据是2，但其实最后是1，原因是线程之间是不可见的。 第一个线程在读这个数的时候是0，假如第二个线程在第一个线程写回前读了这个数，那么它读到的也是0，这个时候第一个线程写回也就是++操作，这个时候这个数是1，而第二个线程对读到的数进行++操作，写回的时候也是1。 我们看代码： public class test4 { public static class MyRunna implements Runnable { public static int count; @Override public void run() { count++; } } public static void main(String[] args) throws InterruptedException { for (int i = 0; i < 1000; i++) { new Thread(new MyRunna()).start(); } Thread

现在测试不同线程下的表现（时间单位ms）： 1 10 50 100 500 1000 5000 synchronized 542 4894 4667 4700 5151 5156 5178 lock 838 1211 821 847 851 1211 1241 可以看到，在多线程环境并存在大量竞争的情况下，synchronized的用时迅速上升，而lock却依然保存不变或增加很少。 Lock是用CAS来实现的 JDK 1.6以上synchronized也改用CAS来实现了，所以两者性能差不多 Lock提供的功能丰富点，synchronized的使用简单点 来源： oschina 链接： https://my.oschina.net/u/1455908/blog/383002

1.引言 基本上所有的并发模式再解决线程冲突的时候，都是采用 序列化访问共享资源 的方案。这意味着在给定时刻只允许一个任务访问共享资源。通常这是通过在代码前面添加一条锁语句来实现的，这就使得在一段时间内只有一个任务可以运行这段代码。因为锁语句产生了一种互相排斥的效果，锁着这种机制常常被称为 互斥量。 Java以提供关键字synchronized的形式，为防止资源冲突提供了内置支持。当任务要执行被synchronized关键字保护的代码片段的时候，它将检查锁是否可用，然后获取锁，执行代码，释放锁 共享资源一般是以对象形式存在的内存片段，但也可以是文件、输入/输出端口，或者是打印机设备。要控制对共享资源的访问，得先把它包装进一个对象。然后把所有要访问这个资源的方法标记为synchronized。如果某个任务处于一个对标记为synchronized方法的调用中，那么在这个线程从该方法返回之前，其他所有要调用类中任何标记synchronized方法的线程都会被阻塞。 2.synchronized原理 在Java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁依赖对象而存在。当我们调用某个对象的synchronized修饰的方法时，就获取了该对象的同步锁。例如synchronized(obj)方法就获取了obj这个对象的同步锁。 不同线程对同步锁的访问是互斥的。也就是说，在某一个时刻

Vector与ArrayList差不多，只不过Vector是线程安全，这也意味着性能会比ArraList差 1、定义 与ArrayList继承、实现接口都一样 2.内部使用数组对象进行存储 使用无参构造方法初始化时，数组大小默认为10 ；这一点与ArrayList不同，ArrayList使用无参构造方法初始化默认为空数组，大小为0； 3.扩容字段 capacityIncrement 正常情况下扩容机制为新的集合大小 = 原来的集合大小+capacityIncrement ，这个与ArrayList不同； ArrayList采用扩容机制为 新的集合大小 = 原来的集合大小+ 原来的集合大小/2 int newCapacity = oldCapacity + (oldCapacity >> 1); 4.部分方法 setSize（） 改变Vector的集合大小，如果newSize大于Vector实际大小会进行Vector扩容，相反，会抛弃newSzie位置索引（包括newSize位置）之后的元素 Vector中大部分方法都如上使用synchronized关键字，进行线程同步，所以性能会比ArrayList差；因为ArrayList是非线程安全的；如果要使用线程安全的List，推荐使用 Collections.synchronizedList(list) ；

Java----线程的同步 文章目录 Java----线程的同步 引入问题 线程同步的方式 使用Synchronized. 同步代码块 同步方法： 使用Lock() synchronized与Lock的对比 引入问题 在关于线程的操作时，往往会遇到线程的安全问题。 这里我用一个例子来说明： package com . CharlesLC_Test ; public class Window_Test { public static void main ( String [ ] args ) { Window window = new Window ( ) ; Thread window1 = new Thread ( window ) ; Thread window2 = new Thread ( window ) ; Thread window3 = new Thread ( window ) ; window1 . setName ( "窗口一" ) ; window2 . setName ( "窗口二" ) ; window3 . setName ( "窗口三" ) ; window1 . start ( ) ; window2 . start ( ) ; window3 . start ( ) ; } } class Window implements Runnable {

我们都知道，随着祖国越来越繁荣昌盛，随着科技的进步，设备的更新换代，计算机体系结构、操作系统、编译程序都在不断地改革创新，但始终有一点是不变的（我对鸭血粉丝的热爱忠贞不渝）：那就是下面三者的性能耗时：CPU < 内存 < I/O 但也正因为这些改变，也就在并发程序中出现了一些诡异的问题，而其中最昭著的三大问题就是：可见性、有序性、原子性。 今天我们就主要来学习一下三者中的可见性。 零、可见性的阐述 可见性 的定义是：一个线程对共享变量的修改，另外一个线程能够立刻看到。 在单核时代，所有线程都在一个CPU上执行，所以一个线程的写，一定是对其它线程可见的。就好比，一个总经理下面就一个项目负责人。 此时，项目经理查看到任务G后，分配给员工A和员工B，那么这个任务的进度就能随时掌握在项目经理手中了；每个员工都能从项目经理处得知最新的项目进度。 而在多核时代后，每个CPU都有自己的缓存，这就出现了可见性问题。 此时，两个项目经理同时查看到任务G后，各自分配给自己下属员工，那么这个任务的进度就只能掌握在各自项目经理手中了，因为所有员工的工作进度并不是汇报给同一个项目经理；那么，每个员工只能得知自己项目组员工的工作进度，并不能得知其他项目组的工作进度。所以，当多个项目经理在做同一个任务时，就可能出现任务配比不均、任务进度拖延、任务重复进行等多种问题。 总结上面的例子来讲，就是因为进度的不及时更新