保证多线程的线程安全都有哪些办法啊？

我只知道  使用 stringbuffer 比 stringbulider 更安全，  其他的不清楚  还没看到线程呢

同步代码块和同步函数
synchronized(对象)
{
       需要被同步的代码块
}
同步函数就是把synchronized作为函数修饰符，同步函数使用的锁使用的是this
静态函数使用的锁是  类名.class
只了解这么多，共勉。

用同步机制，加锁，下面的代码是看视频中敲的，老师讲的详细

1. package com.test.java;
   
2. 
   
3. public class XianC  implements Runnable{
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          *
   
8.          */
   
9.         private int ticket =200;
   
10.         Object obj = new Object();
    
11.         boolean b=true;
    
12.         public void run() {
    
13.                 // TODO Auto-generated method stub
    
14.                 if(b){
    
15.                 while(true){
    
16.                         synchronized(this){
    
17.                         if(ticket>0){
    
18.                                 try {
    
19.                                         Thread.sleep(10);
    
20.                                 } catch (InterruptedException e) {
    
21.                                         // TODO Auto-generated catch block
    
22.                                         e.printStackTrace();
    
23.                                 }
    
24.                                 System.out.println(Thread.currentThread().getName()+" code  "+ticket--);
    
25.                         }
    
26.                         }
    
27.                 }
    
28.         }else
    
29.                 while(true)
    
30.                         show();
    
31.         }
    
32.                 //同步函数  的锁是this
    
33.         //如果换为静态的方法public static synchronized void show()时那么上面的锁应该是XianC.class而不是this锁了
    
34.                 public synchronized void show(){
    
35.                         if(ticket>0){
    
36.                                 //Thread.sleep(10);
    
37.                                 try {
    
38.                                         Thread.sleep(10);
    
39.                                 } catch (InterruptedException e) {
    
40.                                         // TODO Auto-generated catch block
    
41.                                         e.printStackTrace();
    
42.                                 }
    
43.                                 System.out.println(Thread.currentThread().getName()+"  show  "+ticket--);
    
44.                 }
    
45.         }
    
46.         public static void main(String[] args) {
    
47.                 // TODO Auto-generated method stub
    
48.                
    
49.                 XianC xc = new XianC();
    
50.                 //Thread t = new Thread(xc);
    
51.                 Thread t1  = new Thread(xc);
    
52.                 Thread t2 = new Thread(xc);
    
53.                 t1.start();
    
54.                 //如果不加入下面一句话  打印出的结果都是在show方法中的
    
55.                 try{Thread.sleep(10);}catch(Exception e){}
    
56.                 //停留10毫秒  现在只有t1能运行 t1进去为真执行同步代码块 10毫秒就醒了就执行
    
57.                 //xc.b=false这时候为假所以执行同步函数
    
58.                 xc.b=false;
    
59.                 //为什么都在show方法下执行解释如下
    
60.                
    
61.                 t2.start();
    
62.                
    
63.         }
    
64. 
    
65.        
    
66. 
    
67. }
    

复制代码

不懂……

保证多线程运行安全可以理解有以下几种方式：
1、将run()方法中涉及到的赋值代码放入同步代码块中，即synchronized(obj){赋值代码}，obj相当于一把锁；
   
2、将run()方法中要调用到的函数同步，即对函数同步；

3、创建一个锁对象，是之后的升级版本，即，Lock lock =new ReentrantLock();在运行代码的前上锁Lock.lock,线程运行完后释放锁，Lock.unlock。

特别注意的是：当多个线程操作同一资源时（或者涉及到同步嵌套时），所使用到的对象锁必须是同一个，否则会造成死锁或者数据混乱，同时为了保证线程交替运行，需要在运行代码中写入wait()冻结线程和notifyAll()唤醒机制，否则会造成线程一直处于休眠状态。。。

个人理解，可能有一定的不全，仅供交流

同步函数，同步代码块