java 学习 进阶之 一 （线程基础）
一、线程安全
线程安全的概念：当多个线程访问某一个类（对象或方法）时。这个类始终都能表现出正确的行为那么这个类（对象或方法）就是线程安全的。
synchronized：可以在任何对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”
示例：【com.study.base.thread.a_sync.sync001】MyThread
package com.study.base.thread.a_sync.sync001;
/**
*
* 线程安全概念：当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或方法）
* 就是线程安全的
* synchronized:可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”
*
* 示例总结
* 当多个线程访问myThread的run方法时，以排队的方式进处理（这里排队是按照CPU分配的先后顺序商定的），
* 一个线程想要执行Synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容；
* 拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁（也就是会有锁竞争的问题）。
*/
public class MyThread implements Runnable {
private int count = 5; //synchronized 加锁
public synchronized void run() {
count--;
System.out.println(Thread.currentThread().getName()+" count = "+count);
} public static void main(String[] args) {
/**
* 分析：
* 当多个线程访问myThread的run方法时，以排队的方式进行处理（这里排队是按照cpu分配的先后顺序而定的）
* 1 尝试获得锁
* 2 如果拿到锁，执行synchronized代码体内容：拿不到锁出，这个线程就会不断的尝试获得这把锁，直到拿到为止
* 而且是多个线程同时去竞争这把锁，也就是会有锁竞争的问题
*/
MyThread mythread = new MyThread();
Thread t1 = new Thread(mythread,"t1");
Thread t2 = new Thread(mythread,"t2");
Thread t3 = new Thread(mythread,"t3");
Thread t4 = new Thread(mythread,"t4");
Thread t5 = new Thread(mythread,"t5");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start(); }
}
MyThread
示例总结
当多个线程访问myThread的run方法时，以排队的方式进处理（这里排队是按照CPU分配的先后顺序商定的），一个线程想要执行Synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容；拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁（也就是会有锁竞争的问题）。
二、多个线程多个锁
多个线程多个锁：多个线程，每个线程都可以拿到自己指定的锁分别获得锁之后执行synchronized方法体的内容
示例：【com.study.base.thread.a_sync.sync002】MultiThread
package com.study.base.thread.a_sync.sync002;
/**
* 多个线程多个锁：多个线程，每个线程都可以拿到自己指定的锁分别获得锁之后执行synchronized方法体的内容
* 关键字synchronized获取的锁都是对象锁，而不是把一段代码（方法）当做锁，所以示例代码中哪个线程先执行synchronized关键字的方法，哪个线下就持有该方法所属对象的锁（Lock），两个对象。线程获得的就是两个不同的锁，他们互不影响
* 有一种情况则是相同的锁，即使在静态方法上加synchronized关键字，表示锁定.class，类一级别的锁（独占.class类）.
*/
public class MultiThread {
private int num = 0;
public synchronized void printNum(String tag) {
try {
if(tag.equals("a")) {
num = 100;
System.out.println("tag a , set num over");
Thread.sleep(1000);
} else {
num = 200 ;
System.out.println("tag b , set num over");
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("tag "+tag+" , num = "+num);
}
//注意观察run方法的输出顺序
public static void main(String[] args) {
//两个不同的对象
final MultiThread m1 = new MultiThread();
final MultiThread m2 = new MultiThread(); Thread t1 = new Thread(new Runnable() { @Override
public void run() {
// TODO Auto-generated method stub
m1.printNum("a");
}
},"t1");
Thread t2 = new Thread(new Runnable() { @Override
public void run() {
// TODO Auto-generated method stub
m2.printNum("b");
}
},"t2");
t1.start();
t2.start();
}
}
MultiThread
示例总结
关键字synchronized获取的锁都是对象锁，而不是把一段代码（方法）当做锁，所以示例代码中哪个线程先执行synchronized关键字的方法，哪个线下就持有该方法所属对象的锁（Lock），两个对象。线程获得的就是两个不同的锁，他们互不影响 有一种情况则是相同的锁，即使在静态方法上加synchronized关键字，表示锁定.class，类一级别的锁（独占.class类）.
三、对象锁的同步和异步
同步：synchronized 同步的概念就是共享，我们要牢牢记住“共享”这两个字，如果不是共享的资源，就没有必要进行同步
异步：asynchronized 异步的概念就是独立，相互之间不受到任何制约。就好像我们学习http的时候，在页面发起的Ajax请求,我们还可以继续浏览操作页面的内容，两者之间没有任何关系
同步的目的就是为了线程安全，其实对于线程安全来说，需要满足两个特性：
原子性（同步）
可见性
示例：【com.study.base.thread.a_sync.sync003】MyObject
package com.study.base.thread.a_sync.sync003;
/**
*
* 对象的同步和异步问题
*
*/
public class MyObject {
public synchronized void method1() {
try {
System.out.print(Thread.currentThread().getName());
Thread.sleep(4000);
} catch (Exception e) {
e.printStackTrace();
}
} /** synchronized */
public void method2() {
System.out.println(Thread.currentThread().getName());
} public static void main(String[] args) {
final MyObject mo = new MyObject();
/**
* 分析：
* t1线程先持有object对象的lock锁，t2线程可以以异步的方式调用对象中的非synchronized修饰的方法
* t1线程先持有object对象的lock锁，t2线程如果在这个时候调用对象中的同步（synchronized）方法则需等待，也就是同步
*/
Thread t1 = new Thread(new Runnable() { @Override
public void run() {
// TODO Auto-generated method stub
mo.method1();
}
},"t1");
Thread t2 = new Thread(new Runnable() { @Override
public void run() {
// TODO Auto-generated method stub
mo.method2();
}
},"t2");
t1.start();
t2.start();
}
}
MyObject
示例总结
A线程先持有object对象的Lock锁，B线程如果在这个时候调用对象的同步（synchronized）方法则需要等待，也就是同步
A线程先持有object对象的Lock锁，B线程可以以异步的方式调用对象中的非synchronized修饰的方法
四、脏读
对于对象的同步和异步方法，我们在设计自己的程序的时候，一定要考虑问题的整体，不然会出现数据不一致的错误，很经典的错误就是脏读（dirtyread）
示例：【com.study.base.thread.a_sync.sync004】DirtyRead
package com.study.base.thread.a_sync.sync004; /**
* 业务整体需要使用完整的synchronized，保持业务的原子性
*
*
*/
public class DirtyRead {
private String username = "Rang";
private String password = "123";
public synchronized void setValue(String username, String password) {
this.username = username;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
} this.password = password; System.out.println("setValue最终结果, username = " + username + " password = " + password);
} public synchronized void getValue() {
System.out.println("getValue方法得到, username = " + username + " password = " + password);
} public static void main(String[] args) throws InterruptedException { final DirtyRead dr = new DirtyRead();
Thread t1 = new Thread(new Runnable() { @Override
public void run() {
dr.setValue("z3", "456");
} },"t1");
t1.start();
Thread.sleep(1000); dr.getValue(); } }
DirtyRead
示例总结：
在我们对一个对象的方法加锁的时候，需要考虑业务的整体性，即为setValue / getValue 方法同时加锁synchronized同步的关键字，保证业务（service）的原子性，不然会出现业务错误（也从侧面保证业务的一致性）。
五、synchronized 其他概念
synchronized锁重入：关键字synchronized拥有锁重入的功能，也就是使用synchronized时，当一个线程得到一个对象的锁后，再次请求此对象时是可以再次得到该对象的锁的。
示例：【com.study.base.thread.a_sync.sync005】SyncDubbo1
package com.study.base.thread.a_sync.sync005;
/**
* synchronized 的重入
*
*/
public class SyncDubbo1 {
public synchronized void method1() {
System.out.println("method1......");
method2();
}
public synchronized void method2() {
System.out.println("method2......");
method3();
}
public synchronized void method3() {
System.out.println("method3......");
}
public static void main(String[] args) {
final SyncDubbo1 sa = new SyncDubbo1();
Thread t1 = new Thread(new Runnable() { @Override
public void run() {
// TODO Auto-generated method stub
sa.method1();
}
});
t1.start();
} }
SyncDubbo1
示例：【com.study.base.thread.a_sync.sync005】SyncDubbo2
package com.study.base.thread.a_sync.sync005;
/**
* synchronized 的重入
*
*/
public class SyncDubbo2 { static class Main{
public int i = 10;
public synchronized void operationSup() {
try {
i--;
System.out.println("Main print i = "+i);
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} /**
* 有父子继承关系的 互相之间调用有synchronized修饰的方法也是线程安全的
*
*/
static class Sub extends Main{
public synchronized void operationSub() {
try {
while (i > 0) {
i--;
System.out.println("Sub print i = "+i);
Thread.sleep(100);
this.operationSup();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() { @Override
public void run() {
Sub sub = new Sub();
sub.operationSub();
}
});
t1.start();
} }
SyncDubbo2
示例：【com.study.base.thread.a_sync.sync005】SyncException
package com.study.base.thread.a_sync.sync005;
/**
* synchronized 异常
* 异常之后 前后是一个整体时 抛出异常 回滚
* 前后不是一个整体没有关联关系的话 记录日志 continue 执行下个循环
*/
public class SyncException { private int i = 0 ;
public synchronized void operation() {
while (true) {
try {
i++;
Thread.sleep(200);
System.out.println(Thread.currentThread().getName()+", i = "+i);
if (i == 10) {
Integer.parseInt("a");
//throw new RuntimeException();
}
} catch (Exception e) { //InterruptedException
e.printStackTrace();
System.out.println(" log info i = "+i);
//throw new RuntimeException
//continue;
}
}
} public static void main(String[] args) {
final SyncException se = new SyncException();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
se.operation();
}
},"t1");
t1.start();
} }
SyncException
示例说明：
对于web应用程序。异常释放锁的情况，如果不及时处理，很可能对你的应用程序业务逻辑产生严重的错误，比如你现在执行一个队列任务，很多对象都去在等待第一个对象正常执行完毕再去释放锁。但是第一个对象由于异常的出现，导致业务逻辑没有正常执行完毕，就释放了锁。那么可想而知后续的对象执行的都是错误的逻辑。所以这一点一定要引起注意，在编写代码的时候，一定要考虑周全
六、synchronized 代码块
使用synchronized声明的方法在某些情况下是有弊端的，比如A线程调用同B线程就必须等待比较长的时间才能执行，这样的情况下可以使用synchronized代码块去优化代码执行时间，也就是通常所说的减小锁的粒度。
示例：【com.study.base.thread.a_sync.sync006】Optimize
package com.study.base.thread.a_sync.sync006;
import com.study.util.DateUtil;
/**
* 使用synchronized声明的方法在某些情况下是有弊端的，比如A线程调用同B线程就必须等待比较长的时间才能执行，
* 这样的情况下可以使用synchronized代码块去优化代码执行时间，也就是通常所说的减小锁的粒度
*/
public class Optimize { public synchronized void method1 () {
System.out.println("当前线程："+Thread.currentThread().getName()+" 开始 "+DateUtil.getCurrentTimes());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("当前线程："+Thread.currentThread().getName()+" 结束"+DateUtil.getCurrentTimes());
}
public void method2 () {
System.out.println("当前线程："+Thread.currentThread().getName()+" 开始"+DateUtil.getCurrentTimes());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (this) {
System.out.println("当前线程："+Thread.currentThread().getName()+" 执行锁代码块开始"+DateUtil.getCurrentTimes());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("当前线程："+Thread.currentThread().getName()+" 执行锁代码块结束"+DateUtil.getCurrentTimes());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("当前线程："+Thread.currentThread().getName()+" 结束"+DateUtil.getCurrentTimes());
} public static void main(String[] args) {
final Optimize optimize = new Optimize();
Thread t1 = new Thread(new Runnable() { @Override
public void run() {
optimize.method1();
//optimize.method2();
}
}, "t1");
Thread t2 = new Thread(new Runnable() { @Override
public void run() {
optimize.method1();
//optimize.method2();
}
}, "t2");
t1.start();
t2.start();
}
}
Optimize
synchronized可以使用任意的Object进行加锁，用法比较灵活。
示例：【com.study.base.thread.a_sync.sync006】ObjectLock
package com.study.base.thread.a_sync.sync006;
/**
* 使用synchronized代码块加锁，比较灵活
*/
public class ObjectLock { /**
* 对象锁
*/
public void method1() {
synchronized (this) { //对象锁
try {
System.out.println("do method1...");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 类锁
*/
public void method2() {
synchronized (ObjectLock.class) { //类锁
try {
System.out.println("do method2...");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} private Object lock = new Object();
/**
* 任何对象都会锁
*/
public void method3() {
synchronized (lock) { //任何对象
try {
System.out.println("do method3...");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} public static void main(String[] args) {
final ObjectLock objLock = new ObjectLock();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
objLock.method1();
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
objLock.method2();
}
});
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
objLock.method3();
}
});
t1.start();
t2.start();
t3.start();
} }
ObjectLock
另外特别注意一个问题，就是不要使用String的常量加锁，会出现死循环问题。
示例：【com.study.base.thread.a_sync.sync006】StringLock
package com.study.base.thread.a_sync.sync006;
/**
* synchronized 代码块对字符串的锁，注意String常量池的缓存功能
*/
public class StringLock { public void method() {
//new String ("字符串常量")
synchronized ("字符串常量") { // 在常量池中 "字符串常量" 只有一个引用
try {
while(true) {
System.out.println("当前线程："+Thread.currentThread().getName() +"开始");
Thread.sleep(1000);
System.out.println("当前线程："+Thread.currentThread().getName() +"结束");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} public static void main(String [] args) {
final StringLock stringLock = new StringLock();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
stringLock.method();
}
},"t1");
Thread t2 = new Thread(new Runnable() { @Override
public void run() {
// TODO Auto-generated method stub
stringLock.method();
}
},"t2");
t1.start();
t2.start();
} }
StringLock
锁对象的改变问题。当使用一个对象进行加锁的时候，要注意对象本身发生改变的时候，那么持有的锁就不同。如果对象本身不发生改变，那么依然是同步的，即使是对象的属性发生了改变。
示例：【com.study.base.thread.a_sync.sync006】ChangeLock
package com.study.base.thread.a_sync.sync006;
/**
* 锁对象的改变问题
*/
public class ChangeLock { private String lock = "lock"; public void method() {
synchronized (lock) { // 在常量池中 "字符串常量" 只有一个引用
try {
while(true) {
System.out.println("当前线程："+Thread.currentThread().getName() +"开始");
lock = "change lock"; // 修改后锁发生变化了 锁将不在有效 。如果想锁生效不要在方法里修改锁对象的引用
Thread.sleep(2000);
System.out.println("当前线程："+Thread.currentThread().getName() +"结束");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} public static void main(String [] args) {
final ChangeLock changeLock = new ChangeLock();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
changeLock.method();
}
},"t1");
Thread t2 = new Thread(new Runnable() { @Override
public void run() {
// TODO Auto-generated method stub
changeLock.method();
}
},"t2");
t1.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t2.start();
} }
ChangeLock
示例：【com.study.base.thread.a_sync.sync006】ModifyLock
package com.study.base.thread.a_sync.sync006;
/**
* 同一对象属性的修改不会影响锁的情况
*/
public class ModifyLock { private String name ; private int age ; public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public synchronized void changeAttribute(String name, int age ) {
try {
System.out.println("当前线程："+Thread.currentThread().getName() +"开始");
this.setName(name);
this.setAge(age);
System.out.println("当前线程："+Thread.currentThread().getName() +" 修改对象内容为"
+this.getName()+", "+this.getAge());
Thread.sleep(2000);
System.out.println("当前线程："+Thread.currentThread().getName() +"结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
} public static void main(String [] args) {
final ModifyLock modifyLock = new ModifyLock(); // 对象锁 一个对象一个锁
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
modifyLock.changeAttribute("张三", 18);
}
},"t1");
Thread t2 = new Thread(new Runnable() { @Override
public void run() {
// TODO Auto-generated method stub
modifyLock.changeAttribute("李四", 21);
}
},"t2");
t1.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t2.start();
} }
ModifyLock
死锁问题
示例：【com.study.base.thread.a_sync.sync006】DeadLock
package com.study.base.thread.a_sync.sync006;
/**
* 死锁问题 : 比较常见的死锁的产生是因为A线程执行需要得到B线程的占用锁 B线程执行的时候需要A线程占用的锁
**/
public class DeadLock { public static void main(String[] args) {
final Object a = new Object();
final Object b = new Object(); Thread t1 = new Thread(new Runnable() { @Override
public void run() {
synchronized(a) {
System.out.println("t1线程获取到锁a了");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("t1线程准备获取锁b");
synchronized(b) {
System.out.println("t1线程获取到锁b了");
} }
}
},"t1");
Thread t2 = new Thread(new Runnable() { @Override
public void run() {
synchronized(b) {
System.out.println("t2线程获取到锁b了");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("t2线程准备获取锁a");
synchronized(a) {
System.out.println("t2线程获取到锁a了");
}
} }
},"t2");
t1.start();
t2.start(); }
}
DeadLock
七、volitail关键字的使用
Volatile概念：volatile关键字的主要作用是使变量在多个线程间可见。
示例：【com.study.base.thread.a_sync.sync007】
package com.study.base.thread.a_sync.sync007;
/**
* volatile关键字的主要作用是使变量在多个线程间可见
*
*/
public class RunThread extends Thread {
/**
* volatile
*/
private boolean isRunning = true; private void setRunning(boolean isRunning) {
this.isRunning = isRunning;
} public void run() {
System.out.println("进入run方法");
while(isRunning == true) {
//..
}
System.out.print("线程停止");
}
public static void main(String[] args) throws InterruptedException {
RunThread rt = new RunThread();
rt.start();
Thread.sleep(3000);
rt.setRunning(false);
System.out.println("isRunning设置成立false");
Thread.sleep(1000);
System.out.println(rt.isRunning);
}
}
RunThread
示例总结：
在java中，每一个线程都会有一块工作内存区，其中存放着所有线程共享的主内存中的变量值的拷贝。当线程执行时，他在自己的工作内存区中操作这些变量。为了存取一个共享的变量，一个线程通常先获取锁定并去清除它的内存工作区，把这些共享变量从所有线程的共享内存区中正确的装入到他自己所在的工作内存区中，当线程解锁时保证该工作内存区中的变量的值写回到共享内存中。
一个线程可以执行的操作有使用（use）、 赋值（asslgn）、装载（load）、存储（store）、锁定（lock）、解锁（unlocK）
而主内存可以执行的操作有读（read）、写（write）、锁定（lock）、解锁（unlock）每个操作都是原子的
volatile的作用就是强制线程到主内存（共享内存）里去读取变量，而不去线程工作的内存区里去读取，从而实现了线程之间的变量可见，也就满足线程安全的可见性
volatile关键字虽然拥有多个线程之间的可见性，但是却不具有同步性（也就是原子性），可以算上是一个轻量及的synchronized ，性能要比synchronized强很，不会照成阻塞（在很多开源的架构里），比如netty的底层代码就大量使用volatile，可见netty性能一定是非常不错的）这里需要注意：一般volatile用于只针对多个线程可见的变量操作，并不能代替synchronized的同步功能。
示例：【com.study.base.thread.a_sync.sync007】VolatileNoAtomic
package com.study.base.thread.a_sync.sync007;
/**
* Volatile 关键字不具备synchronized关键字的原子性（同步）
* @author Administrator
*
*/
public class VolatileNoAtomic extends Thread {
private static volatile int count;
//private static AtomicInteger count = new AtomicInteger(0); private static void addCount() {
for (int i = 0; i < 1000; i++) {
count++;
//count.incrementAndGet();
}
System.out.println(count);
} public void run() {
addCount();
} public static void main(String[] args) throws InterruptedException {
VolatileNoAtomic[] arr = new VolatileNoAtomic[10];
for (int i = 0; i < 10; i++) {
arr[i] = new VolatileNoAtomic();
} for (int i = 0; i < 10; i++) {
arr[i].start();
}
//最后一次打印10000才是对的 中间可以忽略 （因为可能第一次循环1000次完成以后 后面的线程也在执行++ 导致数据在中间打印的不是完整的1000）。
//如果想要保持原子性推荐使用 AtomicInteger
//CAS非阻塞算法
}
}
VolatileNoAtomic
示例总结：
volatile关键字只具有可见性，没有原子性。要实现原子性建议使用Atomic类的系列对象，支持原子性操作（注意Atomic类只能保证本身方法的原子性，并不保证多次操作原子性）
示例：【com.study.base.thread.a_sync.sync007】AtomicUse
package com.study.base.thread.a_sync.sync007; import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger; public class AtomicUse {
private AtomicInteger count = new AtomicInteger(0); //多个addAndGet在一个方法内是非原子性的，需要加synchronized进行修缮，保证4个addAndGet整体原子性
/** synchronized */
public synchronized int multiAdd() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
count.addAndGet(1);
count.addAndGet(2);
count.addAndGet(3);
count.addAndGet(4);// +10
return count.get();
} public static void main(String[] args) {
final AtomicUse au = new AtomicUse(); List<Thread> ts = new ArrayList<Thread>();
for (int i = 0; i < 100; i++) {
ts.add(new Thread(new Runnable() { @Override
public void run() {
// TODO Auto-generated method stub
System.out.println(au.multiAdd());
}
}));
}
for (Thread t : ts) {
t.start();
}
}
}
AtomicUse
示例总结：
在多线程中同一个方法中多次调用atomic类中的方法，不能保证这个的方法中多次调用atomic类的方法（整体的）原子性，如果想保证此方法中多次调用atomic类的方法（整体的）原子性的那么需要添加synchronized关键字，否者最终结果可能是一致但是中间返回的数据可能不是满10（见示例）
java 学习 进阶之 一 （线程基础）的更多相关文章
- Java学习笔记-多线程-创建线程的方式
创建线程 创建线程的方式: 继承java.lang.Thread 实现java.lang.Runnable接口 所有的线程对象都是Thead及其子类的实例 每个线程完成一定的任务,其实就是一段顺序执行 ...
- java学习之路之javaSE基础2
java学习之路之javaSE基础2 所有的代码都是引用他人写的. 1.逻辑运算符 //&,|,^,! //int x = 10; //5 < x < 15 //x > 5 ...
- java学习之路之javaSE基础1
<h2>java学习之路之javaSE基础1</h2> <div> ###01.01_计算机基础知识(计算机概述)(了解)* A:什么是计算机?计算机在生活中的应用 ...
- JAVA与多线程开发（线程基础、继承Thread类来定义自己的线程、实现Runnable接口来解决单继承局限性、控制多线程程并发）
实现线程并发有两种方式:1)继承Thread类:2)实现Runnable接口. 线程基础 1)程序.进程.线程:并行.并发. 2)线程生命周期:创建状态(new一个线程对象).就绪状态(调用该对象的s ...
- 0036 Java学习笔记-多线程-创建线程的三种方式
创建线程 创建线程的三种方式: 继承java.lang.Thread 实现java.lang.Runnable接口 实现java.util.concurrent.Callable接口 所有的线程对象都 ...
- Java学习之二（线程（了解） JVM GC 垃圾回收）
线程与进程(了解)→JVM→字节码→GC 一.程序 = 算法 + 数据结构(大佬) 二.程序 = 框架 + 业务逻辑(现实) 1.线程与进程.同步与异步 1.1进程是什么? 进程就是操作系统控制的基本 ...
- 0038 Java学习笔记-多线程-传统线程间通信、Condition、阻塞队列、《疯狂Java讲义 第三版》进程间通信示例代码存在的一个问题
调用同步锁的wait().notify().notifyAll()进行线程通信 看这个经典的存取款问题,要求两个线程存款,两个线程取款,账户里有余额的时候只能取款,没余额的时候只能存款,存取款金额相同 ...
- Java 学习笔记 ------第三章 基础语法
本章学习目标: 认识类型与变量 学习运算符的基本使用 了解类型转换细节 运用基本流程语法 一.类型(基本类型) 所谓基本类型,就是在使用时,得考虑一下数据用多少内存长度存比较经济,利用程序语法告诉JV ...
- Java学习个人备忘录之线程间的通信
线程间通讯多个线程在处理同一资源,但是任务却不同. class Resource { String name; String sex; } //输入 class Input implements Ru ...
随机推荐
- VSCode：无法创建临时目录
报错为Could not create temporary directory: 权限被拒绝 解决办法 在VSCode的命令行上输入 sudo chown $USER ~/Library/Caches ...
- [b0002] Hadoop HDFS cmd常用命令练手
目的: 学会HDFS CLI 常用操作 环境: Hadoop 2.6.4 伪分布式版 环境搭建参考本博客前篇文章: 伪分布式 hadoop 2.6.4 帮助: hadoop@ssmaster:~$ h ...
- SQL Server 完整备份遇到的一个不常见的错误
1. 错误详情 有一次在手动执行数据库完整备份时遇到如下错误: 执行多次都是这个错误信息. 提示无法生成检查点,原因可能是由于系统资源(如磁盘或内存空间)不足或者有时是由于数据库损坏而造成的. 我们检 ...
- Shell—三剑客（grep、sed、awk）
grep命令详解 文本搜索工具,根据用户指定的“模式(pattern)”对目标文本进行过滤,显示被模式匹配到的行. 命令格式:grep [options] pattern filename.gr ...
- mysql里字符集的配置
[client]default-character-set=utf8[mysqld]character-set-server = utf8[mysql]default-character-set=ut ...
- 3.Java基础_Java变量
/* 变量定义格式 数据类型 变量名=变量值 基本数据类型: byte,short,int,long,float,double,char,boolean 变量的使用: 取值格式: 变量名 修改值格式: ...
- JS的节流、防抖及使用场景
前言 据说阿里有一道面试题就是谈谈函数节流和函数防抖. 糟了,这可触碰到我的知识盲区了,好像听也没听过这2个东西,痛定思痛,赶紧学习学习.here we go! 概念和例子 函数防抖(debounce ...
- Tensorflow加载预训练模型和保存模型（ckpt文件）以及迁移学习finetuning
转载自:https://blog.csdn.net/huachao1001/article/details/78501928 使用tensorflow过程中,训练结束后我们需要用到模型文件.有时候,我 ...
- go 学习笔记之环境搭建
千里之行始于足下,开始 Go 语言学习之旅前,首先要搭建好本地开发环境,然后就可以放心大胆瞎折腾了. Go 的环境安装和其他语言安装没什么特别注意之处,下载安装包下一步下一步直到完成,可能唯一需要注意 ...
- django haystack报错： ModuleNotFoundError: No module named 'blog.whoosh_cn_backend'
在配置django haystack时报错: 解决方案: 将ENGINE的值 改为 这样就可以了.