Java高并发编程-基础知识点_java 并发编程-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_42215286/article/details/83757010

1.使用synchronized关键字对某个对象进行加锁，任何线程要执行同步代码块中的程序，必须要拿到该对象的锁。

2.在方法上使用synchronized关键字，等同于对当前对象加锁。

public synchronized void method() {
    //等于
    //synchronized(this) { }
}

3.在静态方法上使用synchronized关键字，等同于对当前类加锁。

public synchronized static method() {
    //等于
    //synchronized (当前类.class) { }
}

4.同步方法和和非同步方法可以同时调用。

public class T {

	public synchronized void m1() {
		System.out.println(Thread.currentThread().getName() + " m1 启动.....");
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + " m1 结束.....");
	}
	
	public void m2() {
		System.out.println(Thread.currentThread().getName() + " m2 启动......");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + " m2 结束......");
	}
	
	public static void main(String[] args) {
		T t = new T();
		new Thread(t::m1, "t1").start();
		
//		new Thread(t::m2, "t2").start();      三种方法表达效果相同，但格式不同，前两者是java8的lambda表达式，后者是使用匿名类
//		new Thread(()->t.m2(), "t2").start();
		new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				t.m2();
			}
			
		}, "t2").start();
	}
}

5.脏读问题（dirtyRead）：写业务方法加锁，但读业务方法不加锁。

6.一个同步方法可以调用另一个同步方法。一个线程已经拥有某对象的锁，再一次申请时还是会得到该对象的锁。synchronized锁是可以重入的。子类可以调用父类同步方法。

public class T {
	
	 public synchronized void m() {
		System.out.println(Thread.currentThread().getName() + " m1 启动.....");
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + " m1 结束.....");
	}
	
	public static void main(String[] args) {
		new TT().m();
	}
}

class TT extends T {
	 public synchronized void m() {
		System.out.println("child start");
		super.m();
		System.out.println("child stop");
	}
}

7.在程序的执行过程中，如果出现异常，默认情况下锁会被释放。因此在处理高并发的过程中，应避免异常的产生或者使用try...catch对异常进行捕获。

8.volatile关键字保证了变量的可见性，使一个变量在多个线程间可见。

当多个线程访问一个变量时，会拷贝一份变量在自己工作区，之后就不会去内存中访问该变量。如果其中一个线程对内存中的该变量修改后，其他线程并不会知道该变量改变了，读取的变量值还是自己工作区中的该变量。

使用volatile关键字修饰变量后，到内存中变量值发生改变时，会通知过所以线程，让他们更新自己工作区当中该变量的值。

public class T {

	private volatile boolean flag = true;
	
	public void m() {
		System.out.println("start");
		while(flag) {
//			try {
//				TimeUnit.SECONDS.sleep(2);
//			} catch (InterruptedException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
		}
		System.out.println("end");
	}
	
	public static void main(String[] args) {
		T t = new T();
		new Thread(t::m, "t1").start();
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		t.flag = false;
	}
}

9.volatile不能替代synchronized关键字，它只保证可见性，不保证原子性；而synchronized即保证可见性又保证原子性。

i++是线程不安全的，可以使用synchronized解决该问题。

public class T {

	private volatile int count = 0;
	
	public /*synchronized*/ void m() {
		for(int i = 0; i < 10000; i++) {
			count++;
		}
	}
	
	public static void main(String[] args) {
		T t = new T();
		
		List<Thread> threads = new ArrayList<>();
		
		for (int i = 0; i < 10; i++) {
			threads.add(new Thread(t::m, "thread-" + i));
		}
		
		threads.forEach((o)->o.start());
		
		threads.forEach((o)->{
			try {
				o.join();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		});
		
		System.out.println(t.count);
	}
}

10.解决上述问题还有更高效的方法，使用AtomicXXX类（XXX表示各种包装类），该类中的方法都是原子性的，但是不保证连续调用多个方法是原子性的。

public class T {
	
	private AtomicInteger count = new AtomicInteger(0); 
	
	public void m() {
		for(int i = 0; i < 10000; i++) {
			if (count.get() < 1000) {
				
			}
			count.incrementAndGet();
		}
	}
	
	public static void main(String[] args) {
		T t = new T();
		
		List<Thread> threads = new ArrayList<>();
		
		for(int i = 0; i < 10; i++) {
			threads.add(new Thread(t::m, "thread-"+i));
		}
		
		threads.forEach((o)->o.start());
		
		threads.forEach((o)->{
			try {
				o.join();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		});
		
		System.out.println(t.count);
	}
}

11.锁定某一个对象时，改变对象的属性，不会影响锁的使用；但是对象的引用指向新的对象时，锁就会失效。因此需避免将锁定对象的引用指向新的对象。

12.synchronized的优化，同步代码块中只写需要被加锁的业务操作。这样做锁的粒度会变细，可以使线程争取cpu的时间变短，从而提高效率。

13.不要使用字符串常量作为锁定对象。因为你使用的某个类库中如果对某字符串加了锁，你也对该字符串加了锁，那么就会造成死锁的情况。

String str = "Hello World";

public void method() {

    //避免此操作
    //synchronized(str) { }

}

14.wait和notify方法是对象的方法，wait会释放锁，notify不会释放锁。在程序中线程wait释放锁后，要使用notify唤醒其他线程，为了让其他线程得到锁，在notify后需要使用wait释放锁，这样频繁的wait和notify会让整个通信过程比较繁琐。

为了解决上述问题，使通信简单，可以使用Latch（门闩）的await和countdownlatch方法来代替wait和notify。Latch不涉及同步，当门闩值减为0时，等待的线程便可运行。

public class MyContainer {
	
	private volatile List<Object> os = new ArrayList<>();
	
	public void add(Object o) {
		os.add(o);
	}
	
	public int size() {
		return os.size();
	}
	
	public static void main(String[] args) {
		MyContainer05 c = new MyContainer05();
		CountDownLatch count = new CountDownLatch(1);//定义一个门闩，门闩值设置为1
		
		new Thread(()-> {
				System.out.println("t2 start");
				if (c.size()!=5) {
					try {
						count.await();//线程进行等待
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				System.out.println("t2 end");
		}, "t2").start();
		
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		
		new Thread(()->{
				System.out.println("t1 start");
				for(int i = 0; i < 10; i++) {
					c.add(new Object());
					System.out.println("add "+ (i+1));
					if(c.size() == 5) {
						count.countDown();//门闩值减一，当为0时，门闩打开，让等待线程运行
					}
					try {
						TimeUnit.SECONDS.sleep(1);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
		}, "t1").start();
	}
}

15.reentrantlock可用于代替synchronized，但需要手动释放锁（synchronized锁是JVM自动释放），所以经常在finally中手动释放reentrantlock锁。reentrantlock可调用lockInterruptibly方法对线程的interrupt方法做出相应。

public class ReentrantLock {
	
	public static void main(String[] args) {
		
		Lock lock = new ReentrantLock();
		
		new Thread(()->{
			lock.lock();
			System.out.println("t1 start");
			try {
				TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
			} catch (InterruptedException e) {
				System.out.println("t1 interrupted");
			}finally {
				lock.unlock();
			}
			System.out.println("t1 end");
		}, "t1").start();
		
		Thread t2 = new Thread(()->{
//			lock.lock();
			try {
				lock.lockInterruptibly();//响应t2的interrupt方法
				System.out.println("t2 start");
				TimeUnit.SECONDS.sleep(2);
			} catch (InterruptedException e) {
				System.out.println("t2 interrupted");
			}finally {
				lock.unlock();
			}
			System.out.println("t2 end");
		});
		t2.start();
		
		try {
			TimeUnit.SECONDS.sleep(5);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		t2.interrupt();//打断t2的等待
	}
}

reentrantlock还可指定为公平锁，公平锁：每个线程获得cpu资源的时间相同。

public class ReentrantLock5 extends Thread{
	
	private static Lock lock = new ReentrantLock(true);//当为true时，为公平锁
	
	public void run() {
		for(int i = 0; i < 100; i++) {
			lock.lock();
			try {
				System.out.println(Thread.currentThread().getName() + "获得锁");
			}finally {
				lock.unlock();
			}
		}
	}
	
	public static void main(String[] args) {
		ReentrantLock5 r = new ReentrantLock5();
		new Thread(r, "t1").start();
		new Thread(r, "t2").start();
	}

}

16.线程安全的单例模式。

public class Singleton {

	//构造方法私有化
	private Singleton() {
	}
	
	//静态内部类
	private static class InnerClass {
		private static Singleton s = new Singleton();
	}
	
	public static Singleton get() {
		return InnerClass.s;
	}
	
	public static void main(String[] args) {
		for (int i = 0 ; i < 5; i++) {
			new Thread(()-> {
				Singleton s = Singleton.get();
				System.out.println(s.hashCode() + "----------------");
			}).start();
		}
	}
}

17.同步容器类

Map：

1）并发不是特别高时：

Collections.synchronizedXXX

Hashtable（对整张表加锁）

2）并发比较高时：

ConcurrentHashMap（对表进行分段加锁）

3）并发比较高并且需要排序：

ConcurrentSkipListMap

CopyOnWrite容器（写时复制，写时效率低，但读时效率非常高，并且读时不用加锁，适合写少读多的情况）：

1）CopyOnWriteArrayList

Queue：

1）ConcurrentLinkedQueue（Linked队列是没有界限的，到内存满之前，都可以往队列里加东西）

BlockingQueue（阻塞式队列，添加时如果满了就等待，取出时如果满了就等待）：

添加：put 满了等待；add 满了出异常；offer 添加成功返回true，失败返回false；

1）LinkedBlockingQueue

2）ArrayBlockingQueue（固定大小队列）

3）DelayQueue（执行定时任务队列）

4）LinkedTransferQueue（能大幅度提高并发效率，因为生产者直接将消息给消费者，当没有消费者时，就会等待，因此需要消费者先运行；只有transfer方法才会这样，其他方法在没有消费者情况下，会将消息放入队列中）

5）SynchronousQueue（该队列的容量为0，所以必须有消费者才行；当没有消费者时，因为队列容量为0，所以阻塞等待消费者消费）

18.Runnable接口方法没有返回值，Callable接口方法有返回值。

19.线程池类

线程池的创建方法：

ExecutorService service = Executors.newXXX();

XXX可替代为：

1）FixedThreadPool（固定大小线程池）

2）CachedThreadPool（刚开始时没有线程，当有任务时，会起一个线程执行任务，一段时间（默认60秒）后，线程自动消失）

3）SingleThreadExecutor（该线程池中永远只有一个线程执行任务）

4）ScheduledThreadPool（该线程池中线程按照计划处理任务）

5）WorkStealingPool（1.工作窃取线程池，该线程池中的线程是守护/精灵/后台线程，主线程如果不阻塞的话，是看不见输出的，而且只要JVM不退出，他们会一直在后台执行；2.线程各自维护自己的任务队列，当某个线程执行完自己任务后，会去其他线程的任务队列中取任务来执行）

20.自定义线程池

/**
 * 底层线程池构造方法
 * @param corePoolSize 初始化线程数量
 * @param maximumPoolSize 线程最大数量
 * @param keepAliveTime 线程存活时间
 * @param unit 时间单位
 * @param workQueue 工作队列（上面17条提到的并发容器类，根据需求选择对应的阻塞队列）
 */
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue) { }

//通过该语句创建自定义线程池
ExecutorService threadPoll = new ThreadPoolExecutor(XXX,XXX,XXX,XXX);