(this)同步代码块时,二个数据损坏就总体磨损

本婴儿菜鸟,勿喷!直接上代码了,

super();  

线程范围内分享难点:各类线程之间分享同一块数据,贰个数目损坏就全部磨损,要求的可以运转一下!

    }  

public class Threads {
private static HashMap<Thread, Integer> data = new
HashMap<Thread,Integer>();
public static void main(String[] args) {
for (int i = 0; i < 2; i++) {
new Thread(new Runnable() {

private ObjectService objectService;  

}

    }  

@Override
public void run() {
int value = new Random().nextInt(1000);
data.put(Thread.currentThread(), value);
System.out.println(“名字是:”+Thread.currentThread().getName()+”数据是:”+value);
A a1 = new A();
a1.getData();
B b1 = new B();
b1.getData();
C c = new C();
c.getDate();
}
}).start();
}
}
static class A{
public void getData(){
Thread thread = Thread.currentThread();
int value = data.get(thread);
System.out.println(thread.getName()+”从A中获取数据”+value);
}
}
static class B{
public void getData(){
Thread thread = Thread.currentThread();
int value = data.get(thread);
System.out.println(thread.getName()+”从B中获取数据”+value);
}
}
static class C{
public void getDate() {
Thread thread = Thread.currentThread();
int value = data.get(thread);
System.out.println(thread.getName()+”从C中获取数据”+value);
}
}

System.out.println(“thread name=”+Thread.currentThread().getName()  

 

public void methodA(){  



    }  

try {  



    }  

}catch (InterruptedException e) {  

a.setName(“A”);  

+” 步入代码快:”+System.currentTimeMillis());  

+” 进入代码快:”+System.currentTimeMillis()+”入参uname:”+uname+”入参pwd:”+pwd);  

package com.zwz.thread.demo4;  


}  

2、synchronized(this)同步代码块

public static void main(String[] args) throws InterruptedException {  

}  

for (int i = 1; i <= 10; i++) {  

        }  

    }  

try {  

        }  

图片 1

地方methodA持有ObjectService对象锁,methodB持有lock对象锁,不是同贰个,所以接纳synchronized(任性自定义对象)进行同步操作,对象监视器必须是同三个对象。假若不是同七个,运转就是异步实践了。

package com.zwz.thread.demo5;  

package com.zwz.thread.demo1;  

ThreadB b=new ThreadB(service);  

}catch (InterruptedException e) {  

public ThreadA(ObjectService objectService) {  

public ThreadA(ObjectService objectService) {  


                }  

synchronized (lock) {  

package com.zwz.thread.demo3;  

    }  

}catch (InterruptedException e) {  


ThreadA a=new ThreadA(service);  

package com.zwz.thread.demo2;  

public void run() {  

public class ObjectService {  

a.setName(“A”);  

            }  

synchronized (ObjectService.class) {  

            e.printStackTrace();  

                    e.printStackTrace();  

                pwd=passWord;  

②同时独有五个线程实施synchronized同步方法中的代码。

            }  

        a.start();  

@Override  


        b.start();  

package com.zwz.thread.demo4;  

        a.start();  

Thread.sleep(1000);  

public class ObjectService {  


①对别的的synchronized同步方法或synchronized(this)同步代码块调用是杜绝情况;

public void run() {  

图片 2

        }  

图片 3

    }  

    }  

public void serviceMethodA(){  

图片 4

        b.start();  

图片 5

下面七个小例子大家能够清楚,多少个线程调用同一个目标中的分化名目标synchronized同步方法或synchronized(this)同步代码块时,是同步的。


    }  

结论:

@Override  

+” 步入代码快:”+System.current提姆eMillis());  

public class MainTest {  

    }  

b.setName(“b”);  

        }  

        b.start();  

public void run() {  

        }  


public class ThreadB extends Thread {  

                uname=userName;  


super();  

@Override  

结论:

public ThreadA(ObjectService objectService) {  

package com.zwz.thread.demo3;  

            e.printStackTrace();  


private String pwd;  

                }  


    }  

public class ThreadA extends Thread {  

public void run() {  

public static void main(String[] args) {  

    }  

System.out.println(“static methodB end   线程名称:”+Thread.currentThread().getName()+” times:”+System.currentTimeMillis());  

System.out.println(“synchronized thread name:”+Thread.currentThread().getName()+”–>i=”+i);  

public static void main(String[] args) {  

System.out.println(“methodA end   线程名称:”+Thread.currentThread().getName()+” times:”+System.current提姆eMillis());  

package com.zwz.thread.demo5;  

public void run() {  

b.setName(“B”);  

    }  

        objectService.objectMethodA();  

ThreadB b=new ThreadB(service);  

}catch (InterruptedException e) {  

super();  

        objectService.serviceMethodA();  

ObjectService service=new ObjectService();  

try {  

objectService.setUserNamePassWord(“a”, “aa”);  

public ThreadA(ObjectService objectService) {  

System.out.println(“a   end”);  

        }  

    }  

Thread.sleep(3000);  

public static void main(String[] args) {  

public ThreadB(ObjectService objectService){  

        a.start();  

    }  

public class ObjectService {  

synchronized (this) {  

@Override  

}catch (InterruptedException e) {  

synchronized应用在static方法上,那是对当下对应的*.Class举行持锁。

ThreadB b=new ThreadB(service);  

public void run() {  

        b.start();  

@Override  

ThreadB b=new ThreadB();  


ThreadA a=new ThreadA(service);  

    }  

图片 6

}  

System.out.println(“methodB begin 线程名称:”+Thread.currentThread().getName()+” times:”+System.currentTimeMillis());  

this.objectService = objectService;  

+” 步入代码快:”+System.currentTimeMillis()+”入参uname:”+uname+”入参pwd:”+pwd);  

a.setName(“A”);  

public void run() {  

System.out.println(“thread name=”+Thread.currentThread().getName()  

public class ObjectService {  

public class ObjectService {  

private ObjectService objectService;  

ThreadA a=new ThreadA(service);  

    }  

能够看看没有同步锁的objectMethodA方法异步实践了,下边大家将objectMethodA()加上一只。

synchronized (ObjectService.class) {  

    }  

ObjectService service=new ObjectService();  


运作结果:

    }  

}  


        b.start();  

}  

        a.start();  

            }  

}  

this.objectService=objectService;  


在二十二十四线程开荒中,我们平时见到synchronized(this)、synchronized(*.class)与synchronized(肆意对象)这几种档案的次序同步方法。可是是还是不是清楚那三种写法有何分别了?上边依据代码来剖判:

}  

b.setName(“B”);  

结论:

for (int i = 1; i <= 10; i++) {  

@Override  

public void objectMethodB(){  

super();  

try {  

}  

private String uname;  

3、将轻巧对象作为靶子监视器

运转结果:

package com.zwz.thread.demo1;  

    }  


System.out.println(“A end   time=”+System.currentTimeMillis());  

@Override  

synchronized (this) {  

5、静态同步synchronized方法

super();  

@Override  

b.setName(“B”);  

            }  

a.setName(“a”);  

private ObjectService objectService;  

this.objectService = objectService;  

}  

package com.zwz.thread.demo2;  

public void run() {  

System.out.println(“static methodB begin 线程名称:”+Thread.currentThread().getName()+” times:”+System.currentTimeMillis());  

        objectService.methodB();  

        }  

@Override  


}  

            }  

String lock=new String();  

    }  

private ObjectService objectService;  


synchronized (this) {  

System.out.println(“b begin”);  

上边笔者把String lock=new String();放在方法中:

System.out.println(“a begin”);  

@Override  


ThreadA a=new ThreadA(service);  

public ThreadB(ObjectService objectService) {  

}  

super.run();  

public synchronized void methodB(){  

try {  

try {  

@Override  

package com.zwz.thread.demo6;  

    }  

synchronized (this) {  

package com.zwz.thread.demo3;  

}catch (InterruptedException e) {  

public class ThreadA extends Thread {  

private ObjectService objectService;  

public void objectMethodA(){  

        a.start();  

System.out.println(“thread name=”+Thread.currentThread().getName()  

    }  

private String pwd;  

①对任何的synchronized同步方法或synchronized(this)同步代码块调用是杜绝意况;

        }  


public class ThreadA extends Thread {  

ThreadA a=new ThreadA();  

}  

System.out.println(“static methodA begin 线程名称:”+Thread.currentThread().getName()+” times:”+System.currentTimeMillis());  


package com.zwz.thread.demo2;  

package com.zwz.thread.demo3;  

public class ThreadA extends Thread {  

}  

    }  

当贰个线程访谈ObjectService的贰个synchronized
(this)同步代码块时,其它线程对同二个Object瑟维斯中其它的synchronized
(this)同步代码块的访谈将是杜绝,表达synchronized
(this)使用的是同贰个目的锁。


package com.zwz.thread.demo5;  

private String lock=new String();  

        ObjectService.methodA();  

图片 7

package com.zwz.thread.demo3;  

public void methodB(){  

    }  

运维结果:

objectService.setUserNamePassWord(“b”, “bb”);  


public class ThreadA extends Thread {  

        objectService.serviceMethodB();  

ObjectService service=new ObjectService();  

Thread.sleep(2000);  

System.out.println(“methodB end   线程名称:”+Thread.currentThread().getName()+” times:”+System.currentTimeMillis());  

结论:

public ThreadB(ObjectService objectService) {  

System.out.println(“run—-objectMethodA”);  

        objectService.methodA();  

String lock=new String();  


        a.start();  

}catch (InterruptedException e) {  


this.objectService = objectService;  

this.objectService = objectService;  

System.out.println(“B begin time=”+System.currentTimeMillis());  

super();  

package com.zwz.thread.demo6;  

private String uname;  

public class ThreadB extends Thread {  

a.setName(“A”);  

}  

public void objectMethodB(){  

this.objectService = objectService;  

public void run() {  

private ObjectService objectService;  

2、验证synchronized (this)代码块是锁定当前指标

}  

        objectService.methodB();  

Thread.sleep(2000);  

Thread.sleep(1000);  

Thread.sleep(3000);  


public void methodA(){  

System.out.println(“A begin time=”+System.currentTimeMillis());  

}catch (InterruptedException e) {  

public synchronized void objectMethodA(){  

super();  

public ThreadA(ObjectService objectService){  

}  

    }  

}  

System.out.println(“run—-objectMethodA”);  

package com.zwz.thread.demo2;  

运作结果:

        objectService.objectMethodB();  

运维结果:


    }  

    }  

public class ThreadB extends Thread {  

public void run() {  

结论:

    }  

运作结果:

            e.printStackTrace();  

    }  

synchronized (lock) {  

package com.zwz.thread.demo6;  

ThreadB b=new ThreadB(service);  

public class MainTest {  

}  

    }  


public void serviceMethodB(){  

package com.zwz.thread.demo5;  

            }  

}  

@Override  

public class ObjectService {  

        objectService.methodA();  

    }  


}  

public ThreadB(ObjectService objectService) {  

super();  

    }  

    }  

public synchronized static void methodA(){  

}  

this.objectService = objectService;  

}  

Thread.sleep(3000);  

                    e.printStackTrace();  

②同时独有三个线程实践synchronized同步方法中的代码。

System.out.println(“synchronized thread name:”+Thread.currentThread().getName()+”–>i=”+i);  

public class MainTest {  

package com.zwz.thread.demo1;  

public class ThreadB extends Thread {  

package com.zwz.thread.demo4;  

super.run();  

package com.zwz.thread.demo1;  

super.run();  

        }  

1、synchronized同步方法

1、synchronized代码块间的同步性

this.objectService = objectService;  


System.out.println(“B end   time=”+System.currentTimeMillis());  

运作结果:

System.out.println(“b   end”);  

public void setUserNamePassWord(String userName,String passWord){  

        b.start();  

public class MainTest {  

        }  

public void run() {  

public void setUserNamePassWord(String userName,String passWord){  

            e.printStackTrace();  

super();  

try {  

public synchronized static void methodB(){  

Thread.sleep(3000);  

System.out.println(“methodA begin 线程名称:”+Thread.currentThread().getName()+” times:”+System.current提姆eMillis());  

package com.zwz.thread.demo2;  

图片 8

八个线程持有对象监视器作为同七个目的的前提下,同时唯有叁个线程能够奉行synchronized(大肆自定义对象)同步代码快。

同步synchronized(*.class)代码块的成效其实和synchronized
static方法效果同样。Class锁对类的享有指标实例起成效。

public static void main(String[] args) {  

Thread.sleep(3000);  

    }  

this.objectService=objectService;  

super.run();  

    }  


System.out.println(“thread name=”+Thread.currentThread().getName()  

public class MainTest {  

public class MainTest {  

public class ObjectService {  

private ObjectService objectService;  

public class ObjectService {  

public static void main(String[] args) {  

            e.printStackTrace();  

public class ThreadB extends Thread {  

    }  

System.out.println(“static methodA end   线程名称:”+Thread.currentThread().getName()+” times:”+System.currentTimeMillis());  

ObjectService service=new ObjectService();  

运营结果:

ThreadA a=new ThreadA(service);  

}  

super();  

public void run() {  

    }  

                uname=userName;  

6、synchronized(*.class)代码块

b.setName(“B”);  

synchronized (lock) {  

        ObjectService.methodB();  

private ObjectService objectService;  

    }  

private ObjectService objectService;  

            }  

            e.printStackTrace();  



    }  

}  

private ObjectService objectService;  

    }  

package com.zwz.thread.demo6;  


this.objectService = objectService;  

结论:

public class ThreadB extends Thread {  

public class ThreadA extends Thread {  

4、synchronized(狂妄自定义对象)与synchronized同步方法共用

package com.zwz.thread.demo4;  

public ThreadB(ObjectService objectService) {  

                pwd=passWord;  

ObjectService service=new ObjectService();  

ThreadB b=new ThreadB(service);  

    }  

try {  

相关文章

网站地图xml地图