Java 为什么主线程在启动第一个线程后等待？
我试图理解倒计时锁的用法，下面是我在这里使用的代码 DecrementRunnable.javaJava 为什么主线程在启动第一个线程后等待？,java,java.util.concurrent,countdownlatch,Java,Java.util.concurrent,Countdownlatch,我试图理解倒计时锁的用法，下面是我在这里使用的代码 DecrementRunnable.java package com.nirjhar.java.countdownlatchexample; import java.util.concurrent.CountDownLatch; public class DecrementRunnable implements Runnable { private String name; private Coun
package com.nirjhar.java.countdownlatchexample;
import java.util.concurrent.CountDownLatch;
public class DecrementRunnable implements Runnable {
private String name;
private CountDownLatch cdl;
public DecrementRunnable(String name, CountDownLatch cdl) {
this.name=name;
this.cdl=cdl;
}
@Override
public void run() {
System.out.println("in run method");
for (int i = 0; i < 6; i++) {
cdl.countDown();
System.out.println("counting down "+cdl.getCount());
}
//cdl.notifyAll();
System.out.println("Notified to all");
}
}
package com.nirjhar.java.countdownlatchexample;
import java.util.concurrent.CountDownLatch;
public class CountDownDemoThread extends Thread {
private CountDownLatch cdl;
public CountDownDemoThread(String name, CountDownLatch cdl) {
this.cdl=cdl;
setName(name);
}
@Override
public synchronized void start() {
System.out.println("Task completed ... waiting for other thread to complete their task");
try {
cdl.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Continuing my tasks ..");
}
}
package com.nirjhar.java.countdownlatchexample;
import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
public static void main(String[] args)
{
CountDownLatch cdl=new CountDownLatch(6);
Thread tDecrementThread=new Thread(new DecrementRunnable("Runnable", cdl));
CountDownDemoThread cddt=new CountDownDemoThread("thread", cdl);
cddt.start();
System.out.println("thread 1 started");
tDecrementThread.start();
}
}
在这个主程序中，我希望在线程1启动后打印这一行“thread 1 started”，但是这里的主线程被阻塞了，因为cddt thread中的cdl.await（）语句中有wait语句。只是想知道这背后的原因是什么？在您的
倒计时线程run（）start原因 cdl线程中的wait语句。cddt线程中的wait（）语句。只是想知道这背后的原因是什么 在这种情况下，您已经覆盖了
Threadstart因此没有生成线程，实际上
maincd1.await（）cd1main class Mythread extends Thread
{
public void run()
{
for(int i=0;i<=5;i++)
{
System.out.println("child thread........");
}
}
}
public class ThreadDemo
{
public static void main(String arg[])
{
Mythread t=new Mythread();
// t.setPriority(10);----------(1)
t.start();
for(int i=0;i<=5;i++)
{
System.out.println("main thread........");
}
}
}
2.同步： Synchronized是仅适用于方法和块的修饰符，但不适用于类和变量 如果多个线程试图同时在同一个java对象上操作，则可能存在数据不一致问题 为了克服这个问题，我们应该使用synchronized关键字，如果一个方法或块声明为synchronized，那么一次只允许一个线程在给定对象上执行该方法或块，这样数据不一致的问题就会得到解决 synchronized关键字的主要优点是我们可以解决数据不一致的问题，但synchronized关键字的主要缺点是它会增加线程的等待时间，并会产生性能问题，因此如果没有具体要求，则不建议使用synchronized关键字 内部同步概念是通过使用锁来实现的，java中的每个对象都有一个唯一的锁 每当我们使用synchronized关键字时，只有锁的概念才会出现在图片中 如果线程想首先在给定对象上执行synchronized方法，它必须获得该对象的锁 一旦线程获得了锁，就可以在该对象上执行任何同步方法 一旦方法执行完成，线程就会自动释放锁。获取和释放锁由jvm和不负责此活动的程序员负责 当一个线程在给定对象上执行同步方法时，不允许其余线程在同一对象上同时执行任何同步方法，但允许其余线程同时执行非同步方法 例如：
Class X
{
synchronized void m1() {}
synchronized void m2() {}
public void m3(){}
}
Class X
{
Synchronized();
{
Where ever we are performing update operation
( Add/remove/delete/replace).
That is Where state of object changing.
}
Non-synchronized()
{
Where ever state of object won’t be changed, like only read
operation is performed.
}
}
Class X
{
Synchronized();
{
Where ever we are performing update operation
( Add/remove/delete/replace).
That is Where state of object changing.
}
Non-synchronized()
{
Where ever state of object won’t be changed, like only read
operation is performed.
}
}
class Display{
public synchronized void wish(String name){
for(int i=1;i<=5;i++){
System.out.print("Good Morning:");
try{
Thread.sleep(2000);
}
catch(InterruptedException e){
System.out.println("i got Interrupted");
}
System.out.println(name);
}
}
}
class ThreadDemo extends Thread
{
Display d;
String name;
public ThreadDemo(Display d,String name){
this.d=d;
this.name=name;
}
public void run(){
d.wish(name);
}
}
public class SynchronizedDemo
{
public static void main(String arg[]){
Display d=new Display();
ThreadDemo t1=new ThreadDemo(d,"Avadhoot");
ThreadDemo t2=new ThreadDemo(d,"Abhishek");
ThreadDemo t3=new ThreadDemo(d,"Rinkesh");
ThreadDemo t4=new ThreadDemo(d,"Kushal");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
*级别锁： java中的每个类都有一个唯一的锁，它只是类级锁 如果线程希望执行静态同步方法，则线程需要类级锁
public class SynchronizedDemo
{
public static void main(String arg[])
{
Display d1=new Display();
Display d2=new Display();
Display d3=new Display();
Display d4=new Display();
ThreadDemo t1=new ThreadDemo(d1,"Avadhoot");
ThreadDemo t2=new ThreadDemo(d2,"Abhishek");
ThreadDemo t3=new ThreadDemo(d3,"Rinkesh");
ThreadDemo t4=new ThreadDemo(d4,"Kushal");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
Class X
{
static synchronized m1(){}
static synchronized m2(){}
static m3(){}
synchronized m4(){}
m5(){}
}