Java多线程机制（二）

朴灿烈づ我的快乐病毒、 2023-10-11 10:08 47阅读 0赞

# Java多线程机制 #

### 文章目录 ###

*  Java多线程机制
 *   *   *  一、线程同步
         *  二、死锁问题
         *  三、wait和sleep的区别

### 一、线程同步 ###

1.  synchronized（this）\{…\}，锁定*当前对象*，在执行大括号里面的语句时不会被打断或者说一个线程执行过程中不会被另一个线程打断。synchronized作用就是锁定一段代码，当执行这段代码时锁定当前对象，另外想要访问此对象的线程，只能等当前线程执行完毕后才能访问。还可以写成还可以写成public synchronized void 方法名称(参数列表)\{…\}，意思是在执行此方法过程之中的当前对象被锁定。  
    示例：

package threadtest;
    
    public class TestSync implements Runnable {
        Timer timer = new Timer();
    
        public static void main(String[] args) {
            TestSync testSync = new TestSync();
            Thread t1 = new Thread(testSync);
            Thread t2 = new Thread(testSync);
            t1.setName("t1");
            t2.setName("t2");
            t1.start();
            t2.start();
        }
    
        @Override
        public void run() {
           timer.add(Thread.currentThread().getName());
        }
    
    
    }
    
    class Timer {
        private static int number = 0;
        
        public synchronized void add(String name) {
    //        synchronized (this) {
                number++;
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(name + ",你是第" + number + "个使用timber的线程");
    //        }
        }
    }

未加synchronized之前的结果如下图：  
![执行结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70]  
之所以会出现这样的结果，两个线程访问了同样的的timer对象，是因为当t1线程执行add方法后首先number变成了1，然后t1线程睡眠了1毫秒，此时t2线程开始执行，number变成2，t1线程开始醒过来，输出number为2，t2线程醒过来，输出number也为2（加入sleep方法只是为了放大效果，即使不加，程序也有可能会出现上面的问题）。

== 加入synchronized之后的输出结果如下：==  
![输出结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 1]  
可以看到加入synchronized之后，t1就锁定了*当前对象*，不允许其他线程在对timber对象访问，t1线程执行完毕后t2线程才开始执行。

1.  在Java语言中，引入了对象互斥锁的概念，保证共享数据操作的完整性。每个对象都对应一个可称为“互斥锁”的标记，这个标记保证在同一时刻只能有一个线程访问该对象。
2.  关键字synchronized与对象的互斥锁联系。当某个对象被synchronized修饰时，表明该对象在同一时刻只能由一个线程访问。  
    **synchronized的使用方法：**

synchronized(this){
        
    	num++;
    	try{
        
    		Thread.sleep(1);
    		}
    		catch(InterruptedException e){
        
    			...
    		}
    		System.out.println(name + ", 你是第' + “number” 个使用timer的线程)
    	}
    }

**synchronized还可以放在方法的声明中，表示整个方法为同步方法，即方法里面的当前对象被锁定**

synchronized public  void add(String name){
        ...}

### 二、死锁问题 ###

1.  **概念**：a线程首先锁定了对象o1，然后锁定了对象o2，最后输出某些信息，b线程首先锁定了对象o2，然后锁定对象o1，最后输出信息，a线程想要正常执行必须等待b线程释放对象o2，才能锁定o2，而b线程想要正常执行必须等待a线程释放对象o1，它才能锁定o1,这样就造成了程序的死锁问题。示例代码如下：

package threadtest;
    
    public class TestDeadLock implements Runnable {
        
        public int flag = 1;
        static Object o1 = new Object(), o2 = new Object();
    
        @Override
        public void run() {
        
            System.out.println("flag= " + flag);
            if (flag == 1) {
        
                synchronized (o1) {
        
                    try {
        
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    synchronized (o2) {
        
                        System.out.println("1");
                    }
                }
            }
    
            if (flag == 0) {
        
                synchronized (o2) {
        
                    try {
        
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    synchronized (o1) {
        
                        System.out.println("0");
                    }
                }
            }
        }
    
        public static void main(String[] args) {
        
            TestDeadLock testDeadLock1 = new TestDeadLock();
            TestDeadLock testDeadLock2 = new TestDeadLock();
            testDeadLock1.flag = 1;
            testDeadLock2.flag = 0;
            Thread t1 = new Thread(testDeadLock1);
            Thread t2 = new Thread(testDeadLock2);
            t1.start();
            t2.start();
        }
    }

程序输出如下：  
![运行结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 2]  
从运行结果可以看到，程序已经“死了”，“0”和“1”都不会输出。

1.  如果一个方法做了同步，而另外一个方法没有做同步，那么别的线程可以访问那个非同步的方法，并且可能会对同步的按个方法产生影响。给当前对象加锁（或成为同步），结果是那些非加锁（同步）的方法还可以访问，加了锁的方法只是说明另外一个线程不能在同一个时刻再访问。**互斥**指在某一个时间段保证只有一个线程进入方法中，但不保证其他的线程是不是能进到另一个方法里面（概念性的东西，我听着也晕，了解即可…）

### 三、wait和sleep的区别 ###

1.  **wait时别的线程可以访问锁定对象(调用wait的时候必需锁定该对象（用synchronized），否则是无法调用的)，wait一般和notify或者notifyAll一起使用，用于唤醒线程。**
2.  **sleep时别的线程是无法访问锁定对象的，即线程睡眠过程中仍然持有锁。sleep方法，在睡眠结束后会自动唤醒。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190922180809744.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190922181234906.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191130112107132.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0,size_16,color_FFFFFF,t_70