1. public class Demo04_Synchronized {
   
2. 
   
3. public static void main(String[] args) {
   
4. final Printer p = new Printer();
   
5. 
   
6. new Thread() {
   
7. public void run() {
   
8. while (true)
   
9. p.pirnt1();
   
10. }
    
11. }.start();
    
12. 
    
13. new Thread() {
    
14. public void run() {
    
15. while (true)
    
16. p.pirnt2();
    
17. }
    
18. }.start();
    
19. }
    
20. 
    
21. }
    
22. 
    
23. // 多个线程使用同一个东西时, 有可能出现线程安全问题
    
24. 
    
25. class Printer {
    
26. public synchronized void pirnt1() { // 同步方法, 使用this作为锁, 把整个方法中的代码都同步
    
27. System.out.print("黑");
    
28. System.out.print("马");
    
29. System.out.print("程");
    
30. System.out.print("序");
    
31. System.out.print("员");
    
32. System.out.print("\r\n");
    
33. }
    
34. 
    
35. public void pirnt2() {
    
36. synchronized(this) {
    
37. System.out.print("传");
    
38. System.out.print("智");
    
39. System.out.print("播");
    
40. System.out.print("客");
    
41. System.out.print("\r\n");
    
42. }
    
43. }
    
44. }

复制代码

new Thread() {
public void run() {
while (true)
p.pirnt2();
}
}.start();
}
好处    p 不用继承thread类与实现runnable接口了
问题 1. final Printer p = new Printer(); 为什么是final的
问题 2. this 是什么
问题 3. 锁怎么回事 我的感觉如上实例 一个线程访问p  再来个线程他要看p有没有被使用 如果使用了就等待 这就是锁对不对
问题 4.public static synchronized void pirnt1() 锁的class对象 与this锁什么区别
问题 5.你们知道么 死锁 线程同步异步 线程通信notify() wait()（这有个问题notify唤醒的是那个线程 要想唤醒指定线程能做到不） 与  jdk对线程的支持

问题 1. final Printer p = new Printer(); 为什么是final的
问题 2. this 是什么
问题 3. 锁怎么回事 我的感觉如上实例 一个线程访问p  再来个线程他要看p有没有被使用 如果使用了就等待 这就是锁对不对
问题 4.public static synchronized void pirnt1() 锁的class对象 与this锁什么区别
问题 5.你们知道么 死锁 线程同步异步 线程通信notify() wait()（这有个问题notify唤醒的是那个线程 要想唤醒指定线程能做到不） 与  jdk对线程的支持

答1：当匿名内部类访问到该类的局部变量时，该局部变量必须是final的
答2：this代表的是本类对象的引用，每个类中都隐式的存在一个当前类的引用就是this,this还可以用来区分两个同名变量，如果你的方法区中含有一个this那哪个对象来调用这个方法，那么this就代表哪个对象的引用
答3：锁就是当一个线程进入了被你上锁的部分时其它线程执行到这时必须等待，除非第一个线程执行结束，才能有下一个进程执行该部分内容
答4：同步的前提是必须有两个或者两个以上的线程，必须是多个线程使用同一个锁，所谓死锁就是，线程1要得到两把锁A,B才能执行数据，而线程2也要执行那部分数据，所以她也要拿到A,B锁，当线程1拿到了A锁，而线程2拿到了B锁，这是，线程1需要线程2的锁B，线程2需要线程1的锁A，但它们两个都不释放自己的锁，就出现了一种僵持的状态，这就产生了死锁，notify可以唤醒指定的线程，只要他们的锁相同就可以唤醒指定的线程，所谓异步就是没有锁的情况，线程1正在操作的数据线程2也可以插一脚操作该数据，至于jdk对线程的支持没有懂你的什么意思，以上都是自己的理解

老师 讲的  jdk 1.5对线程的支持   ReentrantLock类  付东老师讲的

final 我要问的是 为什么内部类要用final  {:soso_e132:}

qixing0918 发表于 2013-10-25 12:19
老师 讲的  jdk 1.5对线程的支持   ReentrantLock类  付东老师讲的

java.util.concurrent.lock 中的类 ReentrantLock ，，这是jdk1.5出现的新特性，可以说是 synchronized 功能的替代，它具有相同的内存语义、相同的锁定，但在争用条件下却有更好的性能，此外，它还有 synchronized 没有提供的其他特性，例如用ReentrantLock实现下面的锁
class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() {
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
}
和synchronized效果基本是一样的
public synchronized void m() {
          try {
       // ... method body
     }     }
不过ReentrantLock还有其它更强的功能

qixing0918 发表于 2013-10-25 12:21
final 我要问的是 为什么内部类要用final

用fianl修饰无非就是不想让别人改变它的值，本来我们在方法中定义的局部变量应该是可以直接被定义在方法中的内部类访问的，但内部类和方法的声明周期是不同的，就是当方法生命周期结束时，说明它里面的局部变量也会跟着消失，当内部类中还有对其的引用，但怎样保证这个引用的值不变呢，同过final修饰可以保证它的值不变，即使方法消失时，内部类中这个局部变量的值也不会发生还是之前的那个，你自己也查查资料我这也不一定全对的

哦 辛苦了

qixing0918 发表于 2013-10-25 12:21
final 我要问的是 为什么内部类要用final

当匿名内部类定义在局部位置时，只能访问用final修饰的变量，定义在成员位置时，就不用了