Java总结(6)多线程（二）

最新推荐文章于 2024-03-10 23:38:03 发布

原创最新推荐文章于 2024-03-10 23:38:03 发布 · 744 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了Java中线程的六种状态及其转换过程，包括初始、可运行、运行、阻塞、等待和终止状态，并探讨了多线程安全问题及解决方案。此外，还深入分析了同步代码块和同步函数的使用方法。

线程状态

1、线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了这个对象后，线程就进入了初始状态;
2、当该对象调用了start()方法，就进入可运行状态;
3、进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态;
4、进入运行状态后情况就比较复杂了
　　4.1、run()方法或main()方法结束后，线程就进入终止状态;
　　4.2、当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态(该状态既停止当前线程，但并不释放所占有的资源)。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片;
　　4.3、线程调用了yield()方法，意思是放弃当前获得的CPU时间片，回到可运行状态，这时与其他进程处于同等竞争状态，OS有可能会接着又让这个进程进入运行状态;
　　4.4、当线程刚进入可运行状态(注意，还没运行)，发现将要调用的资源被synchroniza(同步)，获取不到锁标记，将会立即进入锁池状态，等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得)，一旦线程获得锁标记后，就转入可运行状态，等待OS分配CPU时间片;
　　4.5、当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源，与阻塞状态不同)，进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程)，线程被唤醒后会进入锁池，等待获取锁标记。

多线程的安全问题

问题的原因：

当多条哦语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。
另一个线程参与进来执行，导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可参与执行。
同步代码块。
synchronized(对象){
//需要被同步的代码
}
对象如同锁，持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu执行权，也进不去，因为没有获取锁。

同步的前提：

1.必须要有两个或者两个以上的线程。
2.必须是多个线程使用同一个锁
好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。
如何找问题：

1.明确哪些代码是多线程运行代码。

2.明确共享数据。
3.明确多线程运行代码中哪些语句是操作共享数据的。

同步有两种形式：

1.同步代码块：

synchronized(对象){
//需要被同步的代码
}

2.同步函数：

把synchronized作为修饰符放在函数上，此函数就具备了同步的特性。
同步函数用得到是哪一个锁呢？
函数需要被对象调用，那么函数都有一个所属对象引用，就是this。
所以同步函数使用的锁是this。利用如下代码验证：

  private int tick = 100;  
        public void run(){  
            if(flag){  
                while(true){  
                    synchronized(this/*此处未为验证精髓*/){  
                        //同步代码块      
                        if(tick>0){  
                            try{Thread.sleep(10);}catch(Exception e){}  
                            System.out.println(Thread.currentThread().getName()+"..code.."+tick--)  
                        }  
                    }  
                }  
            }else  
                while(true)  
                show();  
        }  
        public synchronized void show(){  
            //需要同步的内容  
            if(tick>0){  
                try{Thread.sleep(10);}catch(Exception e){}  
                System.out.println(Thread.currentThread().getName()+"..show.."+tick--)  
            }  
        }  
        //通过观察输出票数是否安全便可知道，同步函数的锁是否是this  
        public void main(String args[]){  
            new Thread(对象).run();  
            //让线程等待10ms，以便确认0线程已进入代码块  
            try{Thread.sleep(10);}catch(Exception e){}  
            flag=false;  
            new Thread(对象).run();  
        }

静态同步函数，使用的锁是什么呢？
通过验证，不是this，因为静态方法中也不可以定义this。
静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class ，所使用的锁是该方法所在类的字节码文件对象。

(重点)单例设计模式：

饿汉式：

 class Single{  
        //先创建对象，需要的时候直接调用  
        private static final Single s = new Single();  
        //将构造函数私有化，禁止外界的访问。  
        private Single(){}  
        public static Single getInstance(){  
            return s;  
        }  
    }

懒汉式：

class Single{  
        private static Single s = null;  
        private Single(){}  
        public static  Single getInstance(){  
            //双重判断，提高懒汉式的效率，一次创建对象以后，就不再需要判断锁  
            if(s==null){  
                //多线程多次判断锁，影响效率  
                synchronized(Single.class){  
                    //如果不存在对象，才要创建对象，称延迟加载  
                    if(s==null)  
                        s=new Single();  
                }  
            }  
            return s;  
        }  
    }

死锁：

所谓死锁：是指两个或两个以上的进程（线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

例子：

class Test1 implements Runnable  
{  
    private boolean flag;  
    Test1(boolean flag)  
    {  
        this.flag = flag;  
    }  
    public void run()  
    {  
         if(flag)  
         {  
             while(true)  
            {  
                 synchronized(MyLock.locka)  
                 {  
                     System.out.println("if locka");  
                     synchronized(MyLock.lockb)  
                     {  
                         System.out.println("if lockb");  
                     }  
                 }  
             }  
         }  
         else  
         {  
             while(true)  
             {  
                 synchronized(MyLock.lockb)  
                 {  
                     System.out.println("else lockb");  
                     synchronized(MyLock.locka)  
                     {  
                         System.out.println("elcs locka");  
                     }  
                 }  
             }  
  
         }  
    }  
}  
  
class MyLock  
{  
    static Object locka = new Object();  
    static Object lockb = new Object();  
}  
class  DeadLockTest  
{  
    public static void main(String[] args)   
    {  
        new Thread(new Test1(true)).start();  
        new Thread(new Test1(false)).start();  
    }  
}