1、synchronized关键字,代表这个方法加锁,相当于不管哪一个线程(例如线程A),运行到这个方法时,都要检查有没有其它线程B(或者C、 D等)正在用这个方法(或者该类的其他同步方法),有的话要等正在使用synchronized方法的线程B(或者C 、D)运行完这个方法后再运行此线程A,没有的话,锁定调用者,然后直接运行。它包括两种用法:synchronized 方法和 synchronized 块。
2、volatile
一个类型
修饰符(type specifier),就像大家更熟悉的const一样,它是被设计用来修饰被不同线程访问和修改的
变量。
volatile的作用是作为指令
关键字,确保本条指令不会因
编译器的优化而省略,且要求每次直接读值。
volatile的变量是说这变量可能会被意想不到地改变,这样,
编译器就不会去假设这个变量的值了。
3、AtomicInteger是一个提供原子操作的Integer类,通过线程安全的方式操作加减。
使用场景
AtomicInteger提供原子操作来进行Integer的使用,因此十分适合高并发情况下的使用
package com.java.my;
import com.java.my.service.testService;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author wanjiadong
* @description
* @date Create in 9:53 2018/1/31
*/
public class test1 {
static AtomicInteger count = new AtomicInteger(0);
static int n = 0;
public static void main(String[] args) throws Exception {
//第一种newInstance实例一个对象,通常与forName()配合使用
// testService t = (testService) Class.forName("com.java.my.service.testService").newInstance();
// String str = t.checkName("ff");
//
// //使用反射
// Class<?> c = Thread.currentThread().getContextClassLoader().loadClass("com.java.my.service.testService");
// Object cStr = c.getMethod("checkName",String.class).invoke(c.newInstance(),"ff");
// System.out.println(cStr.toString());
//System.out.println(count.get());
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();
Thread.sleep(10000);
System.out.println("count最终执行结果为"+count.get());
System.out.println("n最终执行结果为"+n);
}
static class MyThread extends Thread {
public void run(){
for(int i=0;i<10000;i++){
for(int j=0;j<5;j++){
count.incrementAndGet();
n++;
System.out.println("count="+count.get());
System.out.println("n="+n);
}
}
}
}
}
4、ReentrantLock
package com.java.my;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author wanjiadong
* @description
* @date Create in 15:48 2018/2/1
*/
public class test3 {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
ReentrantLock lock = new ReentrantLock();
Condition con = lock.newCondition();
Runnable run = new Runnable() {
@Override
public void run() {
System.out.println("pre:"+lock.toString());
lock.lock();
try {
con.await(5, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println("post:"+lock.toString());
lock.unlock();
}
}
};
for (int i=0;i<4;i++){
executorService.execute(run);
}
executorService.shutdown();
}
}