Java线程间共享实现方法详解
一、synchronize对象锁和类锁
synchronize为多线程关键字是一种同步锁，它可以修饰以下几种对象：
代码块：被修饰的代码块被称为同步代码块，作用的范围是{}里面的代码，作用的对象是调用这个代码块的对象
方法：被修饰的方法称为同步方法，作用的范围是整个方法，作用的对象是调用这个方法的对象
类：作用的范围是synchronize后面括号里的部分，作用的对象是当前这个类
1、对象锁
下面由一个栗子引入：
publicclassTestSynchronize{
//加了对象锁的方法
privatesynchronizedvoidsyn(){
//自定义sleep工具类
SleepTools.second(2);
System.out.println("synisgoing..."+this.toString());
SleepTools.second(2);
System.out.println("synended..."+this.toString());
}
//调用了对象锁方法的线程1
privatestaticclassthreadimplementsRunnable{
privateTestSynchronizetestSynchronize;
publicthread(TestSynchronizetestSynchronize){
this.testSynchronize=testSynchronize;
}
@Override
publicvoidrun(){
System.out.println("threadisrunning...");
testSynchronize.syn();
}
}
//调用了对象锁方法的线程2
privatestaticclassthread2implementsRunnable{
privateTestSynchronizetestSynchronize;
publicthread2(TestSynchronizetestSynchronize){
this.testSynchronize=testSynchronize;
}
@Override
publicvoidrun(){
System.out.println("thread2isrunning...");
testSynchronize.syn();
}
}
publicstaticvoidmain(String[]args){
TestSynchronizetestSynchronize=newTestSynchronize();
threadthread=newthread(testSynchronize);
TestSynchronizetestSynchronize2=newTestSynchronize();
thread2thread2=newthread2(testSynchronize);
//thread2thread2=newthread2(testSynchronize2);
newThread(thread).start();
newThread(thread2).start();
}
}
/**
当两个线程都将testSynchronize传入时（即使用同一个对象调用加了对象锁的方法）运行结果如下：
threadisrunning...
thread2isrunning...
synisgoing...com.zl.synchronize.TestSynchronize@6b52350c
synended...com.zl.synchronize.TestSynchronize@6b52350c
synisgoing...com.zl.synchronize.TestSynchronize@6b52350c
synended...com.zl.synchronize.TestSynchronize@6b52350c
*/
/**
当一个传入testSynchronize，另一个传入testSynchronize2时运行结果如下：
threadisrunning...
thread2isrunning...
synisgoing...com.zl.synchronize.TestSynchronize@28835f5f
synisgoing...com.zl.synchronize.TestSynchronize@47c48106
synended...com.zl.synchronize.TestSynchronize@28835f5f
synended...com.zl.synchronize.TestSynchronize@47c48106
*/
结论：多个线程调用同一个对象的同步方法会阻塞，调用不同对象的同步方法不会阻塞
2、类锁
1)synchronized修饰的静态方法
publicstaticsynchronizedvoidobj3(){
inti=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+":"+i);
try{
Thread.sleep(500);
}catch(InterruptedExceptionie){
}
}
}
2)synchronized(test.class)，锁的对象是test.class，即test类的锁。
publicvoidobj1(){
synchronized(test.class){
inti=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+":"+i);
try{
Thread.sleep(500);
}catch(InterruptedExceptionie){
}
}
}
}
那么问题来了：在一个类中有两方法，分别用synchronized修饰的静态方法（类锁）和非静态方法（对象锁）。多线程访问两个方法的时候，线程会不会阻塞？
答案是当类锁和对象锁同时存在时，多线程访问时不会阻塞，因为他们不是一个锁。
二、volatile
volatile是一个类型修饰符。volatile的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略。
volatile的特性
- 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。（实现可见性）
- 禁止进行指令重排序。（实现有序性）
- volatile只能保证对单次读/写的原子性。i++这种操作不能保证原子性。
三、ThreadLocal
- ThreadLocal从字面意思来理解，是一个线程本地变量，也可以叫线程本地变量存储。有时候一个对象的变量会被多个线程所访问，这个时候就会有线程安全问题，当然可以使用synchronized关键字来为该变量加锁，进行同步处理来限制只能有一个线程来使用该变量，但是这样会影响程序执行的效率，这时ThreadLocal就派上了用场；
- 使用ThreadLocal维护变量的时候，会为每一个使用该变量的线程提供一个独立的变量副本，即每个线程内部都会有一个当前变量。这样同时有多个线程访问该变量并不会相互影响，因为他们都是使用各自线程存储的变量，所以不会存在线程安全的问题。
- 同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式，前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问且互不影响。
下面给出测试程序：
publicclassThreadLocalDemo{
privatestaticThreadLocalnumber=newThreadLocal(){
@Override
protectedIntegerinitialValue(){
return1;
}
};
privatestaticclassthreadextendsThread{
@Override
publicvoidrun(){
Integernumber=ThreadLocalDemo.number.get();
for(inti=0;i
四、等待(Wait)和通知(notify)
为了支撑多线程之间的协作，JDK提供了两个非常重要的线程接口：等待wait()方法和通知notify()方法。这两个方法并不是在Thread类中的，而是输出在Object类。这意味着任何对象都可以调用这两个方法。
等待/通知的经典范式
wait()方法和notify()方法究竟是如何工作的呢？
如果一个线程调用了object.wait()方法，那么它就会进入object对象的等待队列，这个队列中，可能会有多个线程，因为系统运行多个线程同时等待某一个对象，
当object.notify()方法被调用的时候，它就会从这个等待队列中随机选择一个线程，并进行唤醒。
除notity()方法外，Object对象还有一个类似的notifyAll()方法，它和notity方法的功能基本一致，不同的是，它会唤醒在这个等待队列中所有等待的线程，而不是随机一个。
object.wait()方法并不能随便调用。它必须包含在对象的synchronzied语句中，无论是wait()方法或者notity()方法都需要首先获得目标对象的一个监视器。
假设有T1和T2表示两个线程，T1在正确执行wait()方法前，必须获得object对象的监视器，而wait()方法执行之后会释放这个监视器。
这样做的目的是使其他等待在object对象上的线程不至于因为T1的休眠而全部无法正常执行。
线程T2在notity()方法调用前，也必须获得object对象的监视器。此时T1已经释放了这个监视器。所以T2可以顺利获得object对象的监视器。
接着，T2执行了notify()方法尝试唤醒一个等待线程，这里假设唤醒了T1，T1被唤醒后，要做的第一件事并不是执行后续代码，而是要尝试重新
获得object对象的监视器，而这个监视器也正是T1在wait()方法执行前所持有的那个。
如果暂时无法获得，则T1还必须等待这个监视器。当监视器顺利获得后，T1才可以在真正意义上继续执行。
这里要注意，只有当wait()和notify()被包含的synchronized语句执行完，才会释放监视器。
为了方便理解，简单的案例：
publicclasstestWaitAndNotify{
finalstaticObjectobject=newObject();
publicstaticclassT1extendsThread{
publicvoidrun(){
synchronized(object){
try{
System.out.println(System.currentTimeMillis()+":T1start!");
System.out.println(System.currentTimeMillis()+":T1waitforobject");
object.wait();
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(System.currentTimeMillis()+":T1end!");
}
}
}
publicstaticclassT2extendsThread{
publicvoidrun(){
synchronized(object){
try{
System.out.println(System.currentTimeMillis()+":T2start!notifyonethread");
object.notify();
sleep(5000);
System.out.println(System.currentTimeMillis()+":T2end!");
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}
publicstaticvoidmain(String[]args){
Threadt1=newT1();
Threadt2=newT2();
t1.start();
t2.start();
}
}
/**
1571039516250:T1start!
1571039516250:T1waitforobject
1571039516251:T2start!notifyonethread
1571039521251:T2end!
1571039521251:T1end!
*/
五、等待超时模式
由于经典的等待/通知范式无法做到超时等待，也就是说，当消费者在获得锁后，如果条件不满足，等待生产者改变条件之前会一直处于等待状态，在一些实际应用中，会浪费资源，降低运行效率。
伪代码如下所示：
//假设超时时间是mills，则等待持续时间是remaining,超时时间是future
longfuture=System.currentTimeMillis()+mills;
longremaining=mills;
synchronized(lock){
while(!condition&&remaining>0){
wait(remaining);
remaining=future-System.currentTimeMillis();
}
//处理代码
}
六、join()
join在线程里面意味着“插队”，哪个线程调用join代表哪个线程插队先执行——但是插谁的队是有讲究了，不是说你可以插到队头去做第一个吃螃蟹的人，而是插到在当前运行线程的前面，比如系统目前运行线程A，在线程A里面调用了线程B.join方法，则接下来线程B会抢先在线程A面前执行，等到线程B全部执行完后才继续执行线程A。
话不多说上代码
publicclassTestJoin{
privatestaticclassthreadextendsThread{
privateThreadt;
//接收一个插队线程
publicthread(Threadt){
this.t=t;
}
@Override
publicvoidrun(){
try{
//调用插队线程的join方法
t.join();
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(getName()+"---执行完毕！");
}
}
publicstaticvoidmain(String[]args)throwsInterruptedException{
//获取当前线程作为前一个线程
Threadpre=Thread.currentThread();
//创建五个线程
for(inti=0;i<5;i++){
Threadthread=newThread(newthread(pre),String.valueOf(i));
//启动线程
thread.start();
//重置前一个线程
pre=thread;
}
System.out.println(System.currentTimeMillis());
//让主线程睡眠2s
Thread.currentThread().sleep(2000);
System.out.println(System.currentTimeMillis());
System.out.println(Thread.currentThread().getName()+"---执行完毕");
}
}
/**
1571061168064
1571061170065
main---执行完毕
Thread-0---执行完毕！
Thread-1---执行完毕！
Thread-2---执行完毕！
Thread-3---执行完毕！
Thread-4---执行完毕！
*/
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。