如果说在多线程中加入了同步（以上代码）synchronized(){},那么下面的try{} catch(){}是不是就是多余的了呢？如果不是它的作用在哪里呢？

首先要弄清楚synchronized和try/catch的作用，synchronized是用来同步的，保证锁住的对象此时只能有一个线程来访问，而try/catch是对代码中有可能出现的异常进行抓取捕获，跟synchronized完全是两个不同的东东，两者并不冲突，不要混淆，谁能保证你锁住的对象不出异常呢？明白？

synchronized下是同步代码块，但同步代码块的代码也会出现异常啊，比如角标越界，IO异常，而有些匾编译时检测不出来的，这才有了try,catch代码块，用于检测代码块，捕获异常，避免编译失败的现象的发生，synchronized与try,catch属于不同的类，作用不一样，不能搞混了

synchronized是同步代码块，try,catch是用来检测代码块有没有异常，只要代码块有异常抛出try,catch就有作用。

你应该清楚synchronized是用来同步的，保证锁住的对象此时只能有一个线程来访问，try/catch是对代码中有可能出现的异常进行捕获处理的，两者是不同的哦

写一个简单的程序，测试LinkedList是否线程安全。
你要能把这个搞定，就会发现，你问的问题有多幼稚。

不是多余，如果是单核CPU，一个时间点上只有一个线程在运行，但是如果是多核，同一个时间点上就有多个线程在运行，参考API文档，静态方式sleep抛出的异常是InterruptedException—— 如果另一个线程中断了当前线程。当抛出该异常时，当前线程的中断状态被清除

不多于啊！他们又没什么，假如执行到了，报出异常，你没捕捉呢？

首先synchronized()和try{}catch{}没有必然的关系。synchronized(){}是同步代码块是给在多线程情况下上锁的。try和catch是用来处理异常的。
其次  你之所以会用到try和catch是因为你的try代码块中用到了Thread.sleep()方法，
public static void sleep(long millis)
                  throws InterruptedException//该方法在定义时抛出了异常，
所以在使用时要么继续抛出，要么trycatch处理。

hi，同步synchronized 和 异常处理 try…catch… 之间互不影响。

1、try…catch… 捕获的是Thread.sleep(10); 的中断异常InterruptedException。
2、synchronized 是处理同步的，限制只有一个对象操作。obj相当于一个锁，obj不释放本事的锁，其他的对象是被锁在外面等待的。

synchronized针对线程而言，try…catch…针对异常而言。两者不冲突。

楼主我来回答，你看看合适不：

1. package cn.linjiqian.www;
   
2. /**
   
3. * 黑马论坛上java技术悬赏中心的一道关于线程睡眠抛异常的问题：
   
4. * @author 林吉前
   
5. *
   
6. */
   
7. public class TestThread implements Runnable{
   
8. //1、创建全局变量及线程索引、对象钥匙       
   
9.         private int tick=100;
   
10.         private Thread t1;
    
11.         private Thread t2;
    
12.         private Object obj=new Object();
    
13.         @Override
    
14.         public void run() {
    
15. //2、测试此问题不需要无限循环
    
16.                 while(tick>0){
    
17.                         synchronized(obj){
    
18.                                 if(tick>0){
    
19. //3、可以根据需要设定某种条件中断一个线程线程
    
20.                                         t1.interrupt();
    
21.                                         try {
    
22. //4、中断线程后再睡眠就报了异常，有趣的是这个异常是t1这个线程报的，并不是t2，即使只有一个线程，该异常也抛出
    
23.                                                 Thread.sleep(10);
    
24.                                         } catch (InterruptedException e) {
    
25.                                                 throw new RuntimeException("线程睡眠之前已被中断！");                               
    
26.                                         }
    
27.                                 System.out.println(Thread.currentThread().getName()+":"+tick--);
    
28.                                 }
    
29.                         }
    
30.                 }
    
31.         }
    
32. 
    
33.         public static void main(String[] args) {
    
34.                 TestThread t=new TestThread();
    
35.                 t.t1=new Thread(t);
    
36.                 t.t1.start();
    
37.                 t.t2=new Thread(t);
    
38.                 t.t2.start();
    
39.         }
    
40. }

复制代码

林吉前 发表于 2015-3-9 17:37
楼主我来回答，你看看合适不：

t1的中断状态不是真得中断了，只是身上多了个标记然后该线程继续执行，sleep方法看到这个标记，就会认为该线程是一个中断的线程，就抛了运行时异常这个线程就挂了，但是如果不抛运行时异常，楼主再看：

1. /**
   
2. * 黑马论坛上java技术悬赏中心的一道关于线程睡眠抛异常的问题：
   
3. * @author 林吉前
   
4. *
   
5. */
   
6. public class TestThread implements Runnable{
   
7. //1、创建全局变量及线程索引、对象钥匙       
   
8.         private int tick=100;
   
9.         private Thread t1;
   
10.         private Thread t2;
    
11.         private Object obj=new Object();
    
12.         @Override
    
13.         public void run() {
    
14. //2、测试此问题不需要无限循环
    
15.                 while(tick>0){
    
16.                         synchronized(obj){
    
17.                                 if(tick>0){
    
18. //3、可以根据需要设定某种条件中断一个线程线程
    
19.                                         t1.interrupt();
    
20.                                         try {
    
21. //4、中断线程后再睡眠就报了异常，有趣的是这个异常是t1这个线程报的，并不是t2，即使只有一个线程，该异常也抛出
    
22.                                                 Thread.sleep(10);
    
23.                                         } catch (InterruptedException e) {
    
24.                                                 try {
    
25.                                                         throw new InterruptedException("线程睡眠之前已被中断！");
    
26.                                                 } catch (InterruptedException e1) {
    
27.                                                         e1.printStackTrace();
    
28.                                                 }                               
    
29.                                         }
    
30.                                 System.out.println(Thread.currentThread().getName()+":"+tick--);
    
31.                                 }
    
32.                         }
    
33.                 }
    
34.         }
    
35. 
    
36.         public static void main(String[] args) {
    
37.                 TestThread t=new TestThread();
    
38.                 t.t1=new Thread(t);
    
39.                 t.t1.start();
    
40.                 t.t2=new Thread(t);
    
41.                 t.t2.start();
    
42.         }
    
43. }

复制代码

林吉前 发表于 2015-3-9 17:55
t1的中断状态不是真得中断了，只是身上多了个标记然后该线程继续执行，sleep方法看到这个标记，就会认为 ...

这个线程会一直执行也跟其他线程一样，打印数字，只是多了个异常，一直抛异常，我只要再加个标签：

1. /**
   
2. * 黑马论坛上java技术悬赏中心的一道关于线程睡眠抛异常的问题：
   
3. * @author 林吉前
   
4. *
   
5. */
   
6. public class TestThread implements Runnable{
   
7. //1、创建全局变量及线程索引、对象钥匙       
   
8.         private int tick=100;
   
9.         private Thread t1;
   
10.         private Thread t2;
    
11.         private boolean b=true;
    
12.         private Object obj=new Object();
    
13.         @Override
    
14.         public void run() {
    
15. //2、测试此问题不需要无限循环
    
16.                 while(tick>0){
    
17.                         synchronized(obj){
    
18.                                 if(tick>0){
    
19. //3、可以根据需要设定某种条件中断一个线程线程
    
20.                                         if(b){
    
21.                                                 t1.interrupt();
    
22.                                                 b=false;
    
23.                                         }
    
24.                                         try {
    
25. //4、中断线程后再睡眠就报了异常，有趣的是这个异常是t1这个线程报的，并不是t2，即使只有一个线程，该异常也抛出
    
26.                                                 Thread.sleep(10);
    
27.                                         } catch (InterruptedException e) {
    
28.                                                 try {
    
29.                                                         throw new InterruptedException("线程睡眠之前已被中断！");
    
30.                                                 } catch (InterruptedException e1) {
    
31.                                                         e1.printStackTrace();
    
32.                                                 }                               
    
33.                                         }
    
34.                                 System.out.println(Thread.currentThread().getName()+":"+tick--);
    
35.                                 }
    
36.                         }
    
37.                 }
    
38.         }
    
39. 
    
40.         public static void main(String[] args) {
    
41.                 TestThread t=new TestThread();
    
42.                 t.t1=new Thread(t);
    
43.                 t.t1.start();
    
44.                 t.t2=new Thread(t);
    
45.                 t.t2.start();
    
46.         }
    
47. }
    

复制代码

林吉前 发表于 2015-3-9 17:59
这个线程会一直执行也跟其他线程一样，打印数字，只是多了个异常，一直抛异常，我只要再加个标签： ...

其实这样说跟楼上说的一样，就是异常跟同步没关系的，异常处理可以做其他事，线程做线程的事

有try{} catch(){}主要是sleep();让线程睡一会的，那样能让问题凸显出来，出现负的票。加了synchronized(){}后，不删除sleep()

不多余，synchronized的代码块是防止一条代码块正在执行的时候，被另一条线程抢到执行权，而导致数据出现问题，使用try是因为sleep方法会抛出异常，需要用catch进行处理

并不多余啊，try catch 是为了处理异常的 跟你说的多线程根本不冲突啊

你应该清楚synchronized是用来同步的，保证锁住的对象此时只能有一个线程来访问，try/catch是对代码中有可能出现的异常进行捕获处理的，

举毕老师说的例子，synchronized比作洗手间门上的锁，保证你synchronized里面的东西只有一个线程在执行，就像保证你上厕所时不会有人冲进来和你抢位子，try()catch()就像洗手间里面放的吸盘，当你的代码执行异常的时候try()catch()就可以发现并解决你的代码异常，吸盘的作用就是在你马桶堵了的时候才排上用场的，如果只有一个线程（如果家里只有一个人）你可以不用synchronized（你上厕所可以不用锁门），如果你代码不会出异常（你家厕所不会堵）你可以不用try()catch()（不放吸盘），但锁跟吸盘没有锁门必然联系的，你这里Thread.sleepp()定义了异常（说明你家马桶会堵），所以必须用try()catch(),ok?