java多线程的同步问题

㈠ java中线程同步的几种方法

线程同步主要有以下种方法(示例中是实现计数的功能)：

1、同步方法，即使用synchronized关键字修饰方法，例如：

publicsynchronizedvoidadd(intc){...}

2、同步代码块，即有synchronized关键字修饰的语句块，例如：

publicvoidaddAndGet(intc){
synchronized(this){
count+=c;
}
}

3、使用特殊域变量(volatile)实现线程同步，该方法不能保证绝对的同步。

例如：privatevolatileintcount=0;

4、使用锁实现线程同步，例如：

privateLocklock=newReentrantLock();
publicvoidadd(intc){
lock.lock();//上锁
try{
count+=c;
}finally{
lock.unlock();//解锁
}
}

5、使用原子变量实现线程同步，在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，例如：

privateAtomicIntegercount=newAtomicInteger(1);
publicvoidadd(intc){
count.addAndGet(c);
}

6、使用局部变量实现线程同步，如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本， 副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

ThreadLocal 类的常用方法

new ThreadLocal<T>() : 创建一个线程本地变量

get() : 返回此线程局部变量的当前线程副本中的值

initialValue() : 返回此线程局部变量的当前线程的"初始值"

set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

示例代码：

privatestaticThreadLocal<Integer>count=newThreadLocal<Integer>(){
@Override
protectedIntegerinitialValue(){
return1;
}
};

publicvoidadd(intc){
count.set(count.get()+c);
}

7、使用阻塞队列实现，例如LinkedBlockingQueue，具体使用可网络LinkedBlockingQueue的用法或查看java文档。

㈡ JAVA多线程同步问题

噢，是这样的，不是什么东西都能当做锁，你不能这样理解。
synchronized(obj)，obj这里是你所在类的MIDlet的一个实例对象。

目的是解决因线程不同步而对数据造成破坏的问题。
假如：在一个类中有一个成员变量a,还有两个线程，如果线程不同步的话，这两个线程有可能同时访问同一个变量a,这样的话，就会出现问题，最后执的结果a到底是几呢，所以就要使用线程同步这个办法了。

使用线程同步后，线程1在访问a的时候，我加了一把锁，在这个时候别的线程是不允许访问a的，等线程1对a有访问结束后，就会去掉这把锁，其他的线程再访问a的时候，又会加锁，这样在同一时候，只能有一方访问a,这样就不会出现问题，我说这么多，你明白了吗？希望你能明白，不然我说的算白说了，呵呵！！！！

㈢ Java多线程服务器的同步问题

多线程之所以会出现同步问题，是因为多个线程可以共享资源，对同一资源进行操作，导致不一致的问题，你这个并没有对什么资源进行操作，不会有问题

㈣ Java如何处理多线程的数据同步问题

通过synchronize加锁进行实现进行之间的互斥、通过wait、notify方法实现线程之间的同步。

㈤ Java多线程同步的几种方式

java中多线程的实现方法有两种：1.直接继承thread类；2.实现runnable接口；同步的实现方法有五种：1.同步方法；2.同步代码块；3.使用特殊域变量(volatile)实现线程同步；4.使用重入锁实现线程同步；5.使用局部变量实现线程同步 。
其中多线程实现过程中需注意重写或者覆盖run()方法，而对于同步的实现方法中使用较常使用的是利用synchronized编写同步方法和代码块。
谢谢采纳！！

㈥ java多线程同步问题!

对于这个列子来说确实可以不用加资源同步锁，
其实只有对别的线程可能改变其它线程把持的对象的值的情况才要考虑是否需要同步锁，对于不会改变的情况一般不用考虑，这里的taskList 对象很可能被多个线程同时修改，所以考虑了同步锁，其实List对象的add永远也不会出现添加出错的情况，所以其实这里没什么必要加上同步锁。
而对象一旦加上同步锁，那么当某个线程获得该对象资源，那么该资源被锁定，只能由该线程可以操作，而Object.notify()方法是释放掉该资源，处于等待状态的其它线程可以获得该资源，如果不显示声明notify，当synchronized块执行完后会自动释放。

㈦ java多线程解决同步问题的几种方式，原理和代码

在Java中一共有四种方法支持同步，其中前三个是同步方法，一个是管道方法。管道方法不建议使用。

• wait()/notify()方法

• await()/signal()方法

• BlockingQueue阻塞队列方法

• PipedInputStream/PipedOutputStream

阻塞队列的一个简单实现：

• public class BlockingQueue {


• private List queue = new LinkedList();


• private int limit = 10;



• public BlockingQueue(int limit){


• this.limit = limit;


• }



• public synchronized void enqueue(Object item)throws InterruptedException {


• while(this.queue.size() == this.limit) {


• wait();


• }


• if(this.queue.size() == 0) {


• notifyAll();


• }


• this.queue.add(item);


• }



• public synchronized Object dequeue() throws InterruptedException{


• while(this.queue.size() == 0){


• wait();


• }


• if(this.queue.size() == this.limit){


• notifyAll();


• }



• return this.queue.remove(0);


• }}



在enqueue和dequeue方法内部，只有队列的大小等于上限（limit）或者下限（0）时，才调用notifyAll方法。如果队列的大小既不等于上限，也不等于下限，任何线程调用enqueue或者dequeue方法时，都不会阻塞，都能够正常的往队列中添加或者移除元素。


• wait()/notify()方法

• 生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

  要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。

㈧ java多线程同步的问题

用连接池很好搞定，就是系统开销会大些，连接池的回收会有一些麻烦。

主进程

packageorg.test;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.Future;
importjava.util.concurrent.TimeUnit;
importjava.util.concurrent.TimeoutException;
publicclassTestTheadPool{

publicstaticvoidmain(String[]args){

Future<String>future=null;//每次请求，返回的执行结果
ExecutorServicepool=Executors.newFixedThreadPool(3);//执行pool初始化线程3个分别用于做任务A，任务B，任务C
List<Future<String>>futureList=newArrayList<Future<String>>();//执行结果集

//异步请求调用A
futureList.add(pool.submit(newAsynProcessThread("A")));
//异步请求调用B
futureList.add(pool.submit(newAsynProcessThread("B")));
//异步请求调用C
futureList.add(pool.submit(newAsynProcessThread("C")));
try{
for(inti=0;i<futureList.size();i++){
StringtempResult="";

tempResult=futureList.get(i).get(30000,TimeUnit.MILLISECONDS);//设定超时时间


System.out.println("future["+i+"]result="+tempResult);
}
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(ExecutionExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(TimeoutExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}finally{
pool.shutdown();//这个连接池回收比较简单，没有考虑回收失败的情况。
}
//startprocessD
System.out.println("itisprocessDstart");

System.out.println("itisprocessDend");
}
}

异步线程类

packageorg.test;
importjava.util.Date;
importjava.util.concurrent.Callable;
<String>{

privateStringprocessType;

//构造器
publicAsynProcessThread(StringprocessType){
this.processType=processType;
}
@Override
publicStringcall()throwsException{
DatestartDate=newDate();
System.out.println("process"+processType+"start,time=["+startDate.getTime()+"]");
if("A".equals(processType)){
Thread.sleep(10000);//sleep10秒
}elseif("B".equals(processType)){
Thread.sleep(20000);//sleep20秒
}elseif("C".equals(processType)){
Thread.sleep(15000);//sleep15秒
}
DateendDate=newDate();
System.out.println("process"+processType+"end,time=["+endDate.getTime()+"]total=["+(endDate.getTime()-startDate.getTime())+"]");
return"SUCCESS";
}
}

㈨ JAVA多线程同步的问题

很简单，当不使用的时候，所有的线程都在运行这一个run，因为你没锁，也就是说没锁的听况下，看似只有一个runnable对象，一个run代码块，但是四个线程都在用，这相当于一个房间里面有100本书，是个人都可以同时进入拿，自然四个线程都参与，当你锁起来的时候就相当于一个人进入了就锁了门，其他人都进不去了，只有当那个人出来了，其他人才可以进去，但是，里面是死循环，知道书被那个人都装进麻袋了猜背出来，其他人进去了已经没有了，所以循环直接退出。这样就看似只有一个线程在执行了。