黑马程序员——Java 多线程

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------  

多线程

什么是 进程

        是一个正在执行中的程序。

        进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

什么是线程

         线程就是进程中的一个独立的控制单元。只要进程中有一个线程在执行，进程就不会结束。

        一个进程中至少有一个线程。进程中的多个线程共享进程的内存。

什么事是多线程

      一般来说，当运行一个应用程序的时候，就启动了一个进程，当然有些会启动多个进程。启动进程的时候，操作系统会为进程分配资源，其中最主要的资源是内存空间，因为程序是在内存中运行的。在进程中，有些程序流程块是可以乱序执行的，并且这个代码块可以同时被多次执行。实际上，这样的代码块就是线程体。线程是进程中乱序执行的代码流程。当多个线程同时运行的时候，这样的执行模式成为并发执行。

        多线程的出现能让程序产生同时运行效果。可以提高程序执行效率。

 

二、创建线程的方式

        创建线程共有两种方式：继承方式和实现方式

 继承方式

     第一种方式就是通过继承Thread类，然后复写其run方法的方式来创建线程。

  

 注意：继承Thread的子类新建立的对象直接调用run（）和调用start（）方法的区别 !!! 如下图”

     第二种创建线程的方式：实现Runnable接口

    

第二种方法 程序示例：

class  runnable
{
	public static void main(String[] args) 
	{
		myRunnable run=new myRunnable();
	   // new Thread(run).start();
       // new Thread(run).start();

		Thread t = new Thread(run);
		Thread t1 = new Thread(run);
		t.start();
        //t.start();
		t1.start();
		
		System.out.println("Hello World!");
	}
}


class myRunnable implements Runnable
{
	private int k=20;
  public void run()
	{
	  

	   while(true)  //会出现死循环，用ctrl+c 结束

	   {
		    if(k>0)
			{
				System.out.println(k--);
			}
		   
	   }
	}
}

实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。  

   

 线程安全问题

1、导致安全问题的出现的原因：

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

简单的说就两点：

        a、多个线程访问出现延迟。

        b、线程随机性    。

注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

    解决办法——同步

        对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

        在java中对于多线程的安全问题提供了专业的解决方式——synchronized（同步）

        这里也有两种解决方式，一种是同步代码块，还有就是同步函数。都是利用关键字synchronized来实现。

同步代码块--synchronized（obj）

        用法：

                  Object obj = new Object(); 

                  synchronized（obj）

                  {

                  ..............要同步的多线程运行代码

                  }

              对象如同锁。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

同步函数--synchronized（this）

        格式：

                在函数上加上synchronized修饰符即可。

                函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。

3、同步的前提

        a，必须要有两个或者两个以上的线程。

        b，必须是多个线程使用同一个锁。

4、同步的利弊

        好处：解决了多线程的安全问题。

        弊端：多个线程需要判断锁，较为消耗资源。

5、如何寻找多线程中的安全问题

        a，明确哪些代码是多线程运行代码。

        b，明确共享数据。

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

 

静态函数的同步方式--类名.class

        如果同步函数被静态修饰后，使用的锁是什么呢？

        通过验证，发现不在是this。因为静态方法中也不可以定义this。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。如：

        类名.class 该对象的类型是Class

    

      静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class

死锁

        当同步中嵌套同步时，就有可能出现死锁现象。

/* 
写一个简单的死锁程序 
*/  
  

class LockTest implements Runnable  
{  
    private boolean flag;  
    LockTest(boolean flag)  
    {  
        this.flag=flag;  
    }  
    public void run()  
    {  
        if(flag)  
        {  

                synchronized(LockClass.locka)
                {  
                    System.out.println(Thread.currentThread().getName()+"if_locka");  //第一个线程一直停留在这等待B锁
  
                    synchronized(LockClass.lockb)
                    {  
                    System.out.println(Thread.currentThread().getName()+"if_lockb");  
                    }  
                }  
            
        }  




        else  
        {  
          
                synchronized(LockClass.lockb)
                {  
                  System.out.println(Thread.currentThread().getName()+"else_lockb");  //第二个线程一直停留在这等待A锁
  
                    synchronized(LockClass.locka)
                    {  
                   System.out.println(Thread.currentThread().getName()+"else_locka");  
                    }  
                }  
           
        }  
    }  
}  
  
//定义两个锁  
class LockClass  
{  
    static Object locka = new Object();   //A锁  LockClass.locka
    static Object lockb = new Object();   //B锁  LockClass.lockb
}  
  
class deadlock  
{  
    public static void main(String[] args)  
    {  
        //创建2个进程，并启动  
        new Thread(new LockTest(true)).start();   //进入A锁  等待B锁
        new Thread(new LockTest(false)).start();  //进入B锁，等待A锁
    }  
}  

结果：第一遍通过，第二遍卡住！ 这个只是一次循环，多次循环 不死的几率很小

       

 

 线程间通信

                    其实就是多个线程在操作同一个资源，但是操作的动作不同。

1、使用同步操作同一资源的示例：

--------------------------------------------

wait()

notify(),

notifyAll(),

都使用在同步中，因为要对待有监视器（锁）的线程操作。

所以要使用在同步中，因为只有同步才具有锁！

用来操作线程为什么定义在了Object类中？

                a，这些方法存在与同步中。

                b，使用这些方法时必须要标识所属的同步的锁。同一个锁上wait的线程，只可以被同一个锁上的notify唤醒。

                c，锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。

                也就是说：等待和唤醒必须是同一个锁！！       

 2）wait(),sleep()有什么区别？

              wait():释放cpu执行权，释放锁。

              sleep():释放cpu执行权，不释放锁。

        3）为甚么要定义notifyAll？

        因为在需要唤醒对方线程时。如果只用notify，容易出现只唤醒本方线程的情况。导致程序中的所以线程都等待。

2、JDK1.5中提供了多线程升级解决方案。

        将同步synchronized替换成显示的Lock操作。将Object中wait，notify，notifyAll，替换成了Condition对象。该Condition对象可以通过Lock锁进行获取，并支持多个相关的Condition对象。

升级解决方案的示例：