java的同步代码 java同步代码块
java中的同步代码块，为什么随便放个对象，就可以锁住代码块呢？什么原理？
synchronized(这里的对象你看成一道门) {
成都创新互联总部坐落于成都市区，致力网站建设服务有网站建设、成都网站制作、网络营销策划、网页设计、网站维护、公众号搭建、微信小程序定制开发、软件开发等为企业提供一整套的信息化建设解决方案。创造真正意义上的网站建设，为互联网品牌在互动行销领域创造价值而不懈努力！
这里是一个人进来了，把门反锁了
需要同步操作的代码
这里是里面的人事情做完了，出去了，门开着其他人可以进了
}
至于怎么锁的，这是java和jvm的规定和实现细节，作为普通程序员没必要深入那么多。
浅谈Java多线程的同步问题
多线程的同步依靠的是对象锁机制 synchronized关键字的背后就是利用了封锁来实现对共享资源的互斥访问
下面以一个简单的实例来进行对比分析 实例要完成的工作非常简单 就是创建 个线程 每个线程都打印从 到 这 个数字 我们希望线程之间不会出现交叉乱序打印 而是顺序地打印
先来看第一段代码 这里我们在run()方法中加入了synchronized关键字 希望能对run方法进行互斥访问 但结果并不如我们希望那样 这是因为这里synchronized锁住的是this对象 即当前运行线程对象本身 代码中创建了 个线程 而每个线程都持有this对象的对象锁 这不能实现线程的同步
代码 package vista; class MyThread implements java lang Runnable { private int threadId;
public MyThread(int id) { this threadId = id; }
@Override public synchronized void run() { for (int i = ; i ; ++i) { System out println( Thread ID: + this threadId + : + i); } } }
public class ThreadDemo { /** * @param args * @throws InterruptedException */ public static void main(String[] args) throws InterruptedException { for (int i = ; i ; ++i) { new Thread(new MyThread(i)) start(); Thread sleep( ); } } }
从上述代码段可以得知 要想实现线程的同步 则这些线程必须去竞争一个唯一的共享的对象锁
基于这种思想 我们将第一段代码修改如下所示 在创建启动线程之前 先创建一个线程之间竞争使用的Object对象 然后将这个Object对象的引用传递给每一个线程对象的lock成员变量 这样一来 每个线程的lock成员都指向同一个Object对象 我们在run方法中 对lock对象使用synchronzied块进行局部封锁 这样就可以让线程去竞争这个唯一的共享的对象锁 从而实现同步
代码 package vista;
class MyThread implements java lang Runnable { private int threadId; private Object lock;
public MyThread(int id Object obj) { this threadId = id; this lock = obj; }
@Override public void run() { synchronized (lock) { for (int i = ; i ; ++i) { System out println( Thread ID: + this threadId + : + i); } } } }
public class ThreadDemo { /** * @param args * @throws InterruptedException */ public static void main(String[] args) throws InterruptedException { Object obj = new Object(); for (int i = ; i ; ++i) { new Thread(new MyThread(i obj)) start(); Thread sleep( ); } } }
从第二段代码可知 同步的关键是多个线程对象竞争同一个共享资源即可 上面的代码中是通过外部创建共享资源 然后传递到线程中来实现 我们也可以利用类成员变量被所有类的实例所共享这一特性 因此可以将lock用静态成员对象来实现 代码如下所示
代码 package vista;
class MyThread implements java lang Runnable { private int threadId; private static Object lock = new Object();
public MyThread(int id) { this threadId = id; }
@Override public void run() { synchronized (lock) { for (int i = ; i ; ++i) { System out println( Thread ID: + this threadId + : + i); } } } }
public class ThreadDemo { /** * @param args * @throws InterruptedException */ public static void main(String[] args) throws InterruptedException { for (int i = ; i ; ++i) { new Thread(new MyThread(i)) start(); Thread sleep( ); } } }
再来看第一段代码 实例方法中加入sychronized关键字封锁的是this对象本身 而在静态方法中加入sychronized关键字封锁的就是类本身 静态方法是所有类实例对象所共享的 因此线程对象在访问此静态方法时是互斥访问的 从而可以实现线程的同步 代码如下所示
代码 package vista;
class MyThread implements java lang Runnable { private int threadId;
public MyThread(int id) { this threadId = id; }
@Override public void run() { taskHandler(this threadId); }
private static synchronized void taskHandler(int threadId) { for (int i = ; i ; ++i) { System out println( Thread ID: + threadId + : + i); } } }
lishixinzhi/Article/program/Java/gj/201311/27441
java中实现同步的方法有哪两种?
Java的同步可以用synchronized关键字来实现。\x0d\x0a \x0d\x0asychronized可以同步代码，需要绑定一个对象，如synchronized(obj){}\x0d\x0a也可以同步一个方法，是对方法进行线程同步。如public void synchronized methodA(){}
帮忙解读Java 同步代码
public static Object lock=new Object(); // 创建一个对象， 他是一个静态变量。
public static DataBaseDS getInstance(){
// 这里是判断这个对象是否已经存在
if(sybDB==null){
// 这是一个同步锁， 也就是对于该对象的操作，被强制为同步的,同步也就是说，一次只能有一个用户去操作它，其余的请求都需要排队，就像我们在食堂打饭一样，要一个一个打
synchronized (lock) {
// 如果这个对象为空就创建一个
if(sybDB==null){
sybDB=new DataBaseDS();
}
}
}// 将结果返回
return sybDB;
}
java中线程同步的几种方法
线程同步主要有以下种方法(示例中是实现计数的功能)：
1、同步方法，即使用synchronized关键字修饰方法，例如：
public synchronized void add(int c){...}
2、同步代码块，即有synchronized关键字修饰的语句块，例如：
public void addAndGet(int c){
synchronized(this){
count += c;
}
}
3、使用特殊域变量(volatile)实现线程同步，该方法不能保证绝对的同步。
例如：private volatile int count = 0;
4、使用锁实现线程同步，例如：
private Lock lock = new ReentrantLock();
public void add(int c) {
lock.lock();//上锁
try{
count += c;
}finally{
lock.unlock();//解锁
}
}
5、使用原子变量实现线程同步，在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，例如：
private AtomicInteger count= new AtomicInteger(1);
public void add(int c) {
count.addAndGet(c);
}
6、使用局部变量实现线程同步，如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本， 副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。
ThreadLocal 类的常用方法
new ThreadLocalT() : 创建一个线程本地变量
get() : 返回此线程局部变量的当前线程副本中的值
initialValue() : 返回此线程局部变量的当前线程的"初始值"
set(T value) : 将此线程局部变量的当前线程副本中的值设置为value
示例代码：
private static ThreadLocalInteger count= new ThreadLocalInteger(){
@Override
protected Integer initialValue(){
return 1;
}
};
public void add(int c){
count.set(count.get() + c);
}
7、使用阻塞队列实现，例如LinkedBlockingQueue，具体使用可百度LinkedBlockingQueue的用法或查看java文档。
java中同步有几种方式啊
1。同步代码块：
synchronized(同一个数据){} 同一个数据：就是N条线程同时访问一个数据。
2。
同步方法：
public synchronized 数据返回类型 方法名(){}
就
是使用 synchronized 来修饰某个方法，则该方法称为同步方法。对于同步方法而言，无需显示指定同步监视器，同步方法的同步监视器是
this
也就是该对象的本身（这里指的对象本身有点含糊，其实就是调用该同步方法的对象）通过使用同步方法，可非常方便的将某类变成线程安全的类，具有如下特征：
1，该类的对象可以被多个线程安全的访问。
2，每个线程调用该对象的任意方法之后，都将得到正确的结果。
3，每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态。
注：synchronized关键字可以修饰方法，也可以修饰代码块，但不能修饰构造器，属性等。
实现同步机制注意以下几点： 安全性高，性能低，在多线程用。性能高，安全性低，在单线程用。
1，不要对线程安全类的所有方法都进行同步，只对那些会改变共享资源方法的进行同步。
2，如果可变类有两种运行环境，当线程环境和多线程环境则应该为该可变类提供两种版本：线程安全版本和线程不安全版本(没有同步方法和同步块)。在单线程中环境中，使用线程不安全版本以保证性能，在多线程中使用线程安全版本.
线程通讯：
为什么要使用线程通讯？
当
使用synchronized
来修饰某个共享资源时(分同步代码块和同步方法两种情况）,当某个线程获得共享资源的锁后就可以执行相应的代码段，直到该线程运行完该代码段后才释放对该
共享资源的锁，让其他线程有机会执行对该共享资源的修改。当某个线程占有某个共享资源的锁时，如果另外一个线程也想获得这把锁运行就需要使用wait()
和notify()/notifyAll()方法来进行线程通讯了。
Java.lang.object 里的三个方法wait() notify() notifyAll()
wait方法导致当前线程等待，直到其他线程调用同步监视器的notify方法或notifyAll方法来唤醒该线程。
wait(mills)方法
都是等待指定时间后自动苏醒，调用wait方法的当前线程会释放该同步监视器的锁定，可以不用notify或notifyAll方法把它唤醒。
notify()
唤醒在同步监视器上等待的单个线程，如果所有线程都在同步监视器上等待，则会选择唤醒其中一个线程，选择是任意性的，只有当前线程放弃对该同步监视器的锁定后，也就是使用wait方法后，才可以执行被唤醒的线程。
notifyAll()方法
唤醒在同步监视器上等待的所有的线程。只用当前线程放弃对该同步监视器的锁定后，才可以执行被唤醒的线程
当前文章：java的同步代码 java同步代码块
文章URL：http://mswzjz.cn/article/hjsdio.html