java中什么事线程 同步？java中什么同步什么是异步分别用在什么地方
大家好，感谢邀请，今天来为大家分享一下java中什么事线程 同步的问题，以及和java中什么同步什么是异步分别用在什么地方的一些困惑，大家要是还不太明白的话，也没有关系，因为接下来将为大家分享，希望可以帮助到大家，解决大家的问题，下面就开始吧！
JAVA中线程同步方法有哪些
JAVA中线程同步方法一般有以下三种：
1 wait方法：
该方法属于Object的方法，wait方法的作用是使得当前调用wait方法所在部分（代码块）的线程停止执行，并释放当前获得的调用wait所在的代码块的锁，并在其他线程调用notify或者notifyAll方法时恢复到竞争锁状态（一旦获得锁就恢复执行）。
调用wait方法需要注意几点：
第一点：wait被调用的时候必须在拥有锁（即synchronized修饰的）的代码块中。
第二点：恢复执行后，从wait的下一条语句开始执行，因而wait方法总是应当在while循环中调用，以免出现恢复执行后继续执行的条件不满足却继续执行的情况。
第三点：若wait方法参数中带时间，则除了notify和notifyAll被调用能激活处于wait状态（等待状态）的线程进入锁竞争外，在其他线程中interrupt它或者参数时间到了之后，该线程也将被激活到竞争状态。
第四点：wait方法被调用的线程必须获得之前执行到wait时释放掉的锁重新获得才能够恢复执行。
2 notify方法和notifyAll方法：
notify方法通知调用了wait方法，但是尚未激活的一个线程进入线程调度队列（即进入锁竞争），注意不是立即执行。并且具体是哪一个线程不能保证。另外一点就是被唤醒的这个线程一定是在等待wait所释放的锁。
notifyAll方法则唤醒所有调用了wait方法，尚未激活的进程进入竞争队列。
3 synchronized关键字：
第一点：synchronized用来标识一个普通方法时，表示一个线程要执行该方法，必须取得该方法所在的对象的锁。
第二点：synchronized用来标识一个静态方法时，表示一个线程要执行该方法，必须获得该方法所在的类的类锁。
第三点：synchronized修饰一个代码块。类似这样：synchronized(obj){//code....}。表示一个线程要执行该代码块，必须获得obj的锁。这样做的目的是减小锁的粒度，保证当不同块所需的锁不冲突时不用对整个对象加锁。利用零长度的byte数组对象做obj非常经济。
JAVA中线程在什么时候需要同步和互斥
何时需要同步
在多个线程同时访问互斥（可交换）数据时，应该同步以保护数据，确保两个线程不会同时修改更改它。
对于非静态字段中可更改的数据，通常使用非静态方法访问
对于静态字段中可更改的数据，通常使用静态方法访问。
1、线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。
2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法。
3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。
4、对于同步，要时刻清醒在哪个对象上同步，这是关键。
5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。
6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。
7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。
使用锁定还有一些其他危险，如死锁（当以不一致的顺序获得多个锁定时会发生死锁）。甚至没有这种危险，锁定也仅是相对的粗粒度协调机制，同样非常适合管理简单操作，如增加计数器或更新互斥拥有者。如果有更细粒度的机制来可靠管理对单独变量的并发更新，则会更好一些；在大多数现代处理器都有这种机制。
Java中线程怎么同步
1、使用线程类自带的join方法，将子线程加入到主线程，在子线程执行完之后，在执行主线程逻辑。
例如
[java]view plaincopy
publicstaticvoidjoinDemo()
throwsInterruptedException
{
System.out.println("=========Testwithjoin=====");
JoinWorkerworker1=newJoinWorker("worker1");
JoinWorkerworker2=newJoinWorker("worker2");
worker1.start();
worker2.start();
worker1.join();
worker2.join();
doSuperWork();
}
2、使用JDK的并发包中的CountDownLatch类，使用CountDownLatch，每个线程调用其countDown方法使计数器-1，主线程调用await方法阻塞等待，直到CountDownLatch计数器为0时继续执行，例如
首先，定义子线程
[java]view plaincopy
staticclassCountDownLatchWorkerextendsThread
{
StringworkerName;
CountDownLatchlatch;
publicCountDownLatchWorker(StringworkerName,CountDownLatchlatch)
{
this.workerName=workerName;
this.latch=latch;
}
publicvoidrun()
{
System.out.println("SubWorker"+workerName+"doworkbeginat"
+sdf.format(newDate()));
newThreadWaitDemo().doSomeWork();//做实际工作
System.out.println("SubWorker"+workerName+"doworkcompleteat"
+sdf.format(newDate()));
latch.countDown();//完成之后，计数器减一
}
}
主线程中调研await方法阻塞等待，直到所有线程完成
[html]view plaincopy
publicstaticvoidcountDownLatchDemo()
throwsInterruptedException
{
System.out.println("=========TestwithCountDownLatch=====");
CountDownLatchlatch=newCountDownLatch(2);
CountDownLatchWorkerworker1=newCountDownLatchWorker("worker1",latch);
CountDownLatchWorkerworker2=newCountDownLatchWorker("worker2",latch);
worker1.start();
worker2.start();
//主线程阻塞等待
latch.await();
doSuperWork();
}
3、使用JDK并发包CyclicBarrier，CyclicBarrier类似于CountDownLatch也是个计数器，不同的是CyclicBarrier的await()方法没被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此 CyclicBarrier上面阻塞的线程开始运行。在这之后，如果再次调用 await()方法，计数就又会变成 N-1，新一轮重新开始CyclicBarrier初始时还可带一个Runnable的参数，此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。
示例如下
[java]view plaincopy
publicstaticvoidcyclicBarrierDemo()
throwsInterruptedException,BrokenBarrierException
{
System.out.println("=========TestwithCyclicBarrier=====");
CyclicBarriercb=newCyclicBarrier(2,newRunnable()
{
//将主线程业务放到CyclicBarrier构造方法中，所有线程都到达Barrier时执行
@SuppressWarnings("static-access")
publicvoidrun()
{
newThreadWaitDemo().doSuperWork();
}
});//设定需要等待两个线程
ExecutorServiceexecutor=Executors.newFixedThreadPool(2);
CyclicBarrierWorkerworker1=newCyclicBarrierWorker("worker1",cb);
CyclicBarrierWorkerworker2=newCyclicBarrierWorker("worker2",cb);
executor.execute(worker1);
executor.execute(worker2);
executor.shutdown();
}
4、使用JDK并发包中的Executors框架，ExecutorService的的invokeAll方法调研callable集合，批量执行多个线程，在invokeAll方法结束之后，再执行主线程其他业务逻辑
示例如下
[java]view plaincopy
publicstaticvoidcallableDemo()
throwsInterruptedException
{
System.out.println("=========TestwithCallable=====");
List<Callable<Integer>>callList=newArrayList<Callable<Integer>>();
ExecutorServiceexec=Executors.newFixedThreadPool(2);
//采用匿名内部类实现
callList.add(newCallable<Integer>()
{
publicIntegercall()
throwsException
{
System.out.println("SubWorkerworker1doworkbeginat"+sdf.format(newDate()));
newThreadWaitDemo().doSomeWork();//做实际工作
System.out.println("SubWorkerworker1doworkcompleteat"
+sdf.format(newDate()));
return0;
}
});
callList.add(newCallable<Integer>()
{
publicIntegercall()
throwsException
{
System.out.println("SubWorkerworker2doworkbeginat"+sdf.format(newDate()));
newThreadWaitDemo().doSomeWork();//做实际工作
System.out.println("SubWorkerworker2doworkcompleteat"
+sdf.format(newDate()));
return0;
}
});
exec.invokeAll(callList);
exec.shutdown();
doSuperWork();
}
5、这种过于恶心，只简单说一下方法，主线程创建一个线程List，将每个子线程保存到列表中，然后定期轮询列表中子线程状态，当所有线程都完成之后，再执行主线程逻辑java中什么同步什么是异步分别用在什么地方
java同步指的是synchronized机制，而非synchronized的都是异步，弄懂同步的概念就大致明白了两者的差别。
有关同步：
synchronized用来修饰一个方法或者一个代码块，它用来保证在同一时刻最多只有一个线程执行该段代码。
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
五、以上规则对其它对象锁同样适用。
示例代码：
public class Thread1 implements Runnable{
public void run(){
synchronized(this){
for(int i= 0; i< 5; i++){
System.out.println(Thread.currentThread().getName()+" synchronized loop"+ i);
}
}
}
public static void main(String[] args){
Thread1 t1= new Thread1();
Thread ta= new Thread(t1,"A");
Thread tb= new Thread(t1,"B");
ta.start();
tb.start();
}
}
结果：
A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4
好了，文章到此结束，希望可以帮助到大家。