synchronized

本文主要是学习了 老马说编程 的 计算机程序的思维逻辑 中关于线程部分的知识，并对其进行回顾总结。 多线程的实现 Thread 创建一个Thread的子类，并复写其run()方法，并在需要启动的地方调用其start方法 public class TestThread extends Thread { @Override public void run () { System.out.println( "I'm test thread" ); } } public static void main (String[] args) { Thread testThread = new TestThread(); testThread.start(); } Runnable 创建一个实现了Runnable接口的类，并实现run方法，并在需要启动的地方创建一个Thread对象，并将此类作为参数传入，调用此thread对象的start方法。 public class TestThread implements Runnable { @Override public void run () { System.out.println( "I'm test thread" ); } } public static void main (String[] args) { Thread

My Java Threads does not work independently, how to fix it? This is the initial main: Mechanics mechanics = new Mechanics(busShop, "Mechanic 1"); Mechanics mechanics2 = new Mechanics(busShop, "Mechanic 2"); Thread thMechanic = new Thread(mechanics); Thread thMehanic2 = new Thread(mechanics2); thMechanic.start(); thMehanic2.start(); No problem so far, work as expected, so the mechanics do this: public void run() { fixEngine(); } private void fixEngine() { while (true) { busShop.FixEngine(MechanicsName); } } As seen here it works to fix engine forever, Inside the fix engine function: public

非线程安全：在多个线程对同一个对象中的实例进行并发访问时发生，产生的后果即为脏读。 线程安全：获得的实例变量的值是经过同步处理的，不会出现脏读现象。 非线程安全问题存在于实例变量中，即共享的变量 ，但若是方法内部的私有变量，则不存在非线程安全问题。这是因为方法内部的变量是私有的特性造成的。 如果多个线程同时访问一个对象中的实例变量，则有可能出现非线程安全问题。 解决方法：在方法前加关键字synchronized即可。在两个线程访问同一个对象中的同步方法时一定是线程安全的。 多个对象多个锁。关键字synchronized取得的锁都是对象锁，那个线程先访问带synchronized关键字的方法，那个线程就持有该方法所属对象的锁Lock，那么其他线程就只能处于等待状态，前提是多个线程访问的是同一个对象。 Service service = new Service(); Thread t1 = new Thread(service); Thread t2 = new Thread(service); t1.start(); t2.start(); 但若是多个线程访问多个对象，则jvm就会创建多个锁，则运行结果就是异步的。 Service service1 = new Service(); Service service2 = new Service(); Thread t1 = new

Java 中的锁是可重入的，当线程试图获得它自己占有的锁时，请求会成功。 这样使用 synchronized 并不会造成死锁 public synchronized void test(){ //do something synchronized(this) { //do something synchronized (this){ //do something synchronized (this 大专栏 可重入锁){ //do something } } } } 这是因为java线程是基于 “每线程（per-thread）”，而不是基于“每调用的（per-invocation）” 的，也就是说java为每个线程分配一个锁，而不是为每次调用分配一个锁。 重入的实现是通过为每个锁关联一个请求计数和一个占有它的线程。当请求计数器为0时，这个锁可以被认为是未占用的，当一个线程请求一个未占用的锁时，JVM记录锁的拥有者，并把锁的请求计数加1，如果同一个线程再次请求这个锁时，请求计数器就会增加，当该线程退出 syncronized 块时，计数器减1，当计数器为0时，锁被释放。 来源： https://www.cnblogs.com/liuzhongrong/p/11874801.html

深入比较TheadLocal模式与synchronized关键字 　　 ThreadLocal模式synchronized关键字都用于处理多线程并发访问变量的问题，只是二者处理问题的角度和思路不同。 　　1）ThreadLocal是一个java类，通过对当前线程中的局部变量的操作来解决不同线程的变量访问的冲突问题。所以，ThreadLocal提供了线程安全的共享对象机制，每个线程都拥有其副本。 　　2）Java中的synchronized是一个保留字，它依靠JVM的锁机制来实现临界区的函数或者变量的访问中的原子性。在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。此时，被用作“锁机制”的变量时多个线程共享的。 　　同步机制(synchronized关键字)采用了“以时间换空间”的方式，提供一份变量，让不同的线程排队访问。而ThreadLocal采用了“以空间换时间”的方式，为每一个线程都提供一份变量的副本，从而实现同时访问而互不影响。 来源： https://www.cnblogs.com/panchangde/p/11871243.html

1.Java线程有优先级 ：1~10 static int MAX_PRIORITY：线程可以具有的最高优先级，取值为 10。 static int MIN_PRIORITY：线程可以具有的最低优先级，取值为 1。 static int NORM_PRIORITY：分配给线程的默认优先级，取值为 5。 使用： 主线程优先级为normal；优先级有继承关系，A线程中创建B线程，那么A，B同样优先级 Thread4 t1 = new Thread4( "t1"); t1 .setPriority( Thread .MAX_PRIORITY); //这里设置具体数值也是可以的 getPriority可以获取线程优先级 1.1线程睡眠 不释放锁 sleep()：使线程转为阻塞状态，当sleep结束后，转为就绪 1.2线程等待object中的方法 释放锁 wait()：当前线程等待，释放锁，直到其他线程调用此对象的notify()方法或notifyAll()唤醒方法，行为等价于wait(0) 1.3线程让步 不释放锁 yield()：暂停当前正在执行的对象，把执行机会让给相同或者更高优先级的线程 1.4线程加入 join() ：当前线程调用另一个线程的jion()方法，当前线程进入阻塞状态，直到另一个进程运行结束，当前才阻塞—>就绪 1.5线程唤醒 notify()与notifyAll()

From other questions, I learned that the elements of a volatile array are not volatile. Only the reference itself is volatile. volatile[] int data; Thread A: data[4] = 457; Thread B: System.out.println(data[4]); Here, Thread B might never see the updated value. Which options/alternatives do I have to achieve the same thing? I would like to avoid having to synchronize the array, since it is hardly ever altered. However, it is being read a lot by some threads. Synchronizing it will very likely lower the throughput, which is very important in this example. Is my only option a copy-on-write data

1、异常原因及解释 首先你要了解这个异常为什么会抛出，这个异常会在三种情况下抛出： 1>当前线程不含有当前对象的锁资源的时候，调用obj.wait()方法; 2>当前线程不含有当前对象的锁资源的时候，调用obj.notify()方法。 3>当前线程不含有当前对象的锁资源的时候，调用obj.notifyAll()方法。 java.lang.IllegalMonitorStateException是在调用object的wait和notify，notifyAll方法的时候可能会出现的异常。 在调用上述三个方法的时候，线程必须获得该对象的对象级别锁，换句话说，出现这个异常的原因是因为，调用wait和notify，notifyAll的对象没有在同步方法（synchronized修饰的方法）或者同步代码块（synchronized（x）{}）中。 wait()和notify()方法的调用必须具有内置锁 synchronized(this) 的代码块内或同步方法才能调用，否则就会报该错误。 如果用了显式锁 Lock 就不要用 wait() 和 notify() 了，它们是两套加锁机制，不能混着用的。 2、对象级别加锁 想要获取该对象的对象级别锁，即直接调用Object对象的上述三个方法，也就只有在同步方法或同步代码块中。（同步方法或同步代码块以当前对象this作为同步监视器）。 3