synchronized

https://www.cnblogs.com/houzheng/p/9084026.html 一、对象锁和类锁 1.对象锁：也就是方法锁 是针对一个对象实例的，它只在该对象的某个内存位置声明一个标识该对象是否拥有锁，所以它只会锁住当前的对象，而并不会对其他对象实例的锁产生任何影响，不同对象访问同一个被synchronized修饰的方法的时候不会阻塞 例如 public class MyObject { private synchronized void method1 ( ) { try { System . out . println ( Thread . currentThread ( ) . getName ( ) ) ; Thread . sleep ( 4000 ) ; } catch ( InterruptedException e ) { e . printStackTrace ( ) ; } } //synchronized修饰为同步方法,如果先调用method1,则4秒后才会调用method2 //如果不用synchronized修饰,则可以直接异步调用,没有影响 private void method2 ( ) { System . out . println ( Thread . currentThread ( ) . getName ( ) ) ; } }

/** * * 总结：当方法上添加synchronized时，只有当当前线程执行完，下一个线程才可以进入执行 */ public class SychronizedMethod { public synchronized void print(){ System.out.println(Thread.currentThread().getName()+"开始打印"); try{ sleep(1000); }catch (InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"打印结束"); } public static void main(String args[]){ Test test = new Test(); Thread t1 = new Thread(test); Thread t2 = new Thread(test); Thread t3 = new Thread(test); Thread t4 = new Thread(test); t1.start(); t2.start(); t3.start(); t4.start(); } } class Test implements Runnable{

线程的状态转化关系 （1）. 新建状态（New）：新创建了一个线程对象。 （2）. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。 （3）. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。 （4）. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种： - 等待阻塞（WAITING）：运行的线程执行wait()方法，JVM会把该线程放入等待池中。 - 同步阻塞（Blocked）：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。 - 超时阻塞（TIME_WAITING）：运行的线程执行sleep(long)或join(long)方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。 （5）. 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。 下面的流程感觉有点问题，可以参考： 1、线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了这个对象后，线程就进入了初始状态; 　　2、当该对象调用了start()方法，就进入可运行状态;

文章目录 源码 疑惑 解惑 写在最后 源码 在阅读Guava限流器代码相关实现时，很多操作都需要加锁，比如在setRate方法中： public final void setRate ( double permitsPerSecond ) { checkArgument ( permitsPerSecond > 0.0 && ! Double . isNaN ( permitsPerSecond ) , "rate must be positive" ) ; synchronized ( mutex ( ) ) { doSetRate ( permitsPerSecond , stopwatch . readMicros ( ) ) ; } } 上述代码的重点即是 synchronized (mutex()){} ，用来在真正的修改速率(doSetRate)方法前加锁，避免出现并发问题。 接下来看 mutex() 方法： // Can't be initialized in the constructor because mocks don't call the constructor. @MonotonicNonNull private volatile Object mutexDoNotUseDirectly ; private Object mutex ( ) {

线程的同步，为什么要线程同步？ 线程并发执行时，可能会操作同一个资源（比如变量），如果线程A操作了资源，但是还没执行完，线程B又操作了资源，会引发资源数据不一致，不准确的问题。 示例： public class Test4 { public static void main ( String [ ] args ) { TestSync testSync = new TestSync ( ) ; Thread t1 = new Thread ( testSync , "t1" ) ; Thread t2 = new Thread ( testSync , "t2" ) ; t1 . start ( ) ; t2 . start ( ) ; } } class TestSync implements Runnable { Timer timer = new Timer ( ) ; public void run ( ) { try { timer . add ( Thread . currentThread ( ) . getName ( ) ) ; } catch ( InterruptedException e ) { e . printStackTrace ( ) ; } } } class Timer { public static int num = 0 ; public

线程的创建 有四种方式： 1、实现Runnable接口并重写run()方法 public class StartRun implements Runnable{ public void run() { } } 使用：//创建实现类对象 StartRun st=new StartRun(); //创建代理类对象 Thread t=new Thread(st); //启动 开启线程 t.start(); //不保证立即运行，由cpu调用 2、继承Thread类并重写run()方法 public class StartThread extends Thread{ public void run() { } } 使用：//创建子类对象 StartThread st=new StartThread(); //启动 开启线程 st.start(); //不保证立即运行，由cpu调用 3、使用Collable并重写call()接口 class Run implements Callable{ //里面是泛型 @Override public Object call() throws Exception { return null; } } 必须使用ExecutorService.submit()方法 调用它 submit会返回一个对象Future，可以使用get()方法来得到该结果 4

转载出处： https://www.cnblogs.com/zhaoyan001/p/6077492.html Vector 可实现自动增长的对象数组。 java.util.vector提供了向量类(vector)以实现类似动态数组的功能。在Java语言中没有指针的概念，但如果正确灵活地使用指针又确实可以大大提高程序的质量。比如在c,c++中所谓的“动态数组”一般都由指针来实现。为了弥补这个缺点，Java提供了丰富的类库来方便编程者使用，vector类便是其中之一。事实上，灵活使用数组也可以完成向量类的功能，但向量类中提供大量的方法大大方便了用户的使用。 创建了一个向量类的对象后，可以往其中随意插入不同类的对象，即不需顾及类型也不需预先选定向量的容量，并可以方便地进行查找。对于预先不知或者不愿预先定义数组大小，并且需要频繁地进行查找，插入，删除工作的情况。可以考虑使用向量类。 向量类提供了三种构造方法： public vector() public vector(int initialcapacity,int capacityIncrement) public vector(int initialcapacity) 使用第一种方法系统会自动对向量进行管理，若使用后两种方法。则系统将根据参数，initialcapacity设定向量对象的容量（即向量对象可存储数据的大小）

synchronized是非公平锁，reentrantlock可以指定为公平锁。 synchronized修饰非静态的方法时，所对象为当前类的class单例对象。 ReentrantLock可以替代synchronized，使用synchronized锁定如果遇到一场，jvm会自动释放锁，使用reentrantlock必须手动释放锁，一般在finally中释放。 reentrantlock可是使用trylock尝试锁定，这样无法锁定，或者在给定的时间无法锁定，线程可以决定继续等待。 使用ReentrantLock还可以调用lockInterruptibly方法，对象成interrupt方法做出相应。 参考： https://segmentfault.com/a/1190000019737594 Synchronized的底层实现 https://www.cnblogs.com/mingyao123/p/7424911.html 来源： CSDN 作者： pink baby 链接： https://blog.csdn.net/weixin_40027906/article/details/103866678

1.ConcurrentHashmap简介 在使用 HashMap 时在多线程情况下扩容会出现CPU接近100%的情况，因为hashmap并不是线程安全的，通常我们可以使用在java体系中古老的 hashtable 类，该类基本上所有的方法都采用synchronized进行线程安全的控制，可想而知，在高并发的情况下，每次只有一个线程能够获取对象监视器锁，这样的并发性能的确不令人满意。另外一种方式 通过Collections的Map<K,V> synchronizedMap(Map<K,V> m)将hashmap包装成一个线程安全的map 。比如SynchronzedMap的put方法源码为： public V put(K key, V value) { synchronized (mutex) {return m.put(key, value);} } 实际上 SynchronizedMap实现依然是采用synchronized独占式锁进行线程安全的并发控制的 。同样，这种方案的性能也是令人不太满意的。针对这种境况，Doug Lea大师不遗余力的为我们创造了一些线程安全的并发容器，让每一个java开发人员倍感幸福。 相对于hashmap来说，ConcurrentHashMap就是线程安全的map，其中利用了锁分段的思想提高了并发度 。 ConcurrentHashMap在JDK1