黑马程序员技术交流社区

标题: 线程问题 [打印本页]
作者: ﹌★ㄊ蕾oo-    时间: 2011-10-16 13:00
标题: 线程问题
当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
作者: 赵玉成    时间: 2011-10-16 15:47
可以。
Java 中的每个对象都有一个锁，当访问某个对象的synchronized方法时，表示将该对象上锁，
此时其他任何线程都无法访问该synchronized方法了,直到之前的那个线程方法完毕或是抛出了异常，
则该对象将锁释放掉，其他线程才可能去访问该synchronized方法。
如果一个对象有多个synchronized方法，某个线程已经进入到了某个synchronized方法，在该方法没有执行
完毕前，其他线程无法访问该对象的任何synchronized方法，但其它线程可进入此对象的其它方法。

请运行示例：
public class MyThreadTest
{
        public static void main(String[] args)
        {
                Demo example = new Demo();

                Thread t1 = new TheThread33(example);

                Thread t2 = new TheThread44(example);

                Thread t3 = new TheThread55(example);

                t1.start();
                t2.start();
                t3.start();
        }
}

class Demo
{
        public synchronized void execute()
        {
                for (int i = 0; i < 10; i++)
                {
                        try
                        {
                                Thread.sleep(500);
                        }
                        catch (InterruptedException e)
                        {
                                e.printStackTrace();
                        }

                        System.out.println("hello: " + i);
                }
        }

        public synchronized void execute2()
        {
                for (int i = 0; i < 10; i++)
                {
                        try
                        {
                                Thread.sleep(500);
                        }
                        catch (InterruptedException e)
                        {
                                e.printStackTrace();
                        }

                        System.out.println("world: " + i);
                }
        }

        public void output()
        {
                for (int x = 0; x < 10; x++)
                {
                        try
                        {
                                Thread.sleep(600);
                        }
                        catch (InterruptedException e)
                        {
                                e.printStackTrace();
                        }
                        System.out.println("你好啊");
                }
        }

}

class TheThread33 extends Thread
{
        private Demo example;

        public TheThread33(Demo example)
        {
                this.example = example;
        }

        @Override
        public void run()
        {
                this.example.execute();
        }
}

class TheThread44 extends Thread
{
        private Demo example;

        public TheThread44(Demo example)
        {
                this.example = example;
        }

        @Override
        public void run()
        {
                this.example.output();
        }
}

class TheThread55 extends Thread
{
        private Demo example;

        public TheThread55(Demo example)
        {
                this.example = example;
        }

        @Override
        public void run()
        {
                this.example.execute2();
        }
}
作者: 宁超    时间: 2011-10-16 22:28
这个要看是同步方法还是非同步方法了。
如果是同步方法的话是不可以的。
如果是非同步方法的话是可以的。
我用代码来演示下。
  1. package Test;

  3. public class Test1
  4. {
  5.         public static void main(String[] args)
  6.         {
  7.                 ThreadDemo threadDemo=new ThreadDemo();
  8.                 Thread t1=new ThreadOne(threadDemo);
  9.                 Thread t2=new ThreadTwo(threadDemo);
  10.                 Thread t3=new ThreadThree(threadDemo);
  11.                 t1.start();
  12.                 t2.start();
  13.                 t3.start();

  15.         }

  17. }

  19. class ThreadDemo
  20. {

  22.         public synchronized void method1()
  23.         {
  24.                 for (int i = 0; i < 10; i++)
  25.                 {
  26.                         try
  27.                         {
  28.                                 Thread.sleep(500);
  29.                         } catch (InterruptedException e)
  30.                         {
  31.                                 e.printStackTrace();
  32.                         }
  33.                         System.out.println("同步方法1"+"    "+ i);
  34.                 }
  35.         }

  37.         public synchronized void method2()
  38.         {
  39.                 for (int i = 0; i < 10; i++)
  40.                 {
  41.                         try
  42.                         {
  43.                                 Thread.sleep(500);
  44.                         } catch (InterruptedException e)
  45.                         {
  46.                                 e.printStackTrace();
  47.                         }
  48.                         System.out.println("同步方法2"+"    " + i);
  49.                 }
  50.         }

  52.         public void Print()
  53.         {
  54.                 for (int i = 0; i < 10; i++)
  55.                 {
  56.                         try
  57.                         {
  58.                                 Thread.sleep(500);
  59.                         } catch (InterruptedException e)
  60.                         {
  61.                                 e.printStackTrace();
  62.                         }
  63.                         System.out.println("非同步方法" + i);
  64.                 }
  65.         }
  66. }

  68. class ThreadOne extends Thread
  69. {
  70.         private ThreadDemo threadDemo;

  72.         public ThreadOne(ThreadDemo threadDemo)
  73.         {
  74.                 this.threadDemo = threadDemo;
  75.         }

  77.         public void run()
  78.         {
  79.                 this.threadDemo.method1();
  80.         }
  81. }

  83. class ThreadTwo extends Thread
  84. {
  85.         private ThreadDemo threadDemo;

  87.         public ThreadTwo(ThreadDemo threadDemo)
  88.         {
  89.                 this.threadDemo = threadDemo;
  90.         }

  92.         public void run()
  93.         {
  94.                 this.threadDemo.method2();
  95.         }
  96. }

  98. class ThreadThree extends Thread
  99. {
  100.         private ThreadDemo threadDemo;

  102.         public ThreadThree(ThreadDemo threadDemo)
  103.         {
  104.                 this.threadDemo = threadDemo;
  105.         }

  107.         public void run()
  108.         {
  109.                 this.threadDemo.Print();
  110.         }

  112. }
复制代码
定义ThreadDemo类 有三个方法metho1，method2，Print。
其中metho1，method2为同步方法。Print为非同步方法。
如果在主函数中只开启t1.start()和t2.start();则输出结果为
t1输出完后，t2在输出。所以如果是同步方法的话是不可以的。

如果在主函数中只开启t1.start()和t3.start();则输出结果为
t1，Print交替输出。所以如果是非同步方法的话是可以的。
作者: o火o把o    时间: 2011-10-21 22:44
如果这个对象中有多个方法都上了锁,而且上锁的方法中内部调用了wait,那有wait的线程执行到wait会释放执行权给其他上锁的线程.



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2