多线程小结（一）

多线程小结

    看了三四天视频，终于把多线程学完了，进度有点慢了，后面要更努力了，先鼓励自己一下。

  讲线程前需要先知道另一个名词，那就是进程，进程就是一个正在执行中的程序。

    每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

    线程就是进程中的一个独立的控制单元。

    线程在控制着进程的执行，一个进程中至少有一个线程。

知道了什么事线程之后，那就要讲如何创建线程了。创建线程有两种方法：继承Thread类 ， 实现Runable接口

1.继承Thread类来创建线程

  用该方法来创建线程时，需要将类声明为Thread类的子类，该子类应重写Thread类的run()方法。

  在主线程中实例化该类，调用start()方法启动线程，start()方法会自动调用类的run()方法。

  run()方法中存放的就是线程要运行的代码。

<span style="font-size:14px;">class Demo extends Thread
{
	public void run()
	{
		for(int x=0; x<60; x++)
			System.out.println("demo run----"+x);
	}
}
class ThreadDemo 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();      //创建好一个线程。
		d.start();                //开启线程并执行该线程的run方法。
		//d.run();                //如果直接调用run()方法的话，仅仅是对象调用方法。
                                          //而线程创建了，并没有运行。
		for(int x=0; x<60; x++)
			System.out.println("Hello World!--"+x);
	
	}
}</span>

2.实现Runable接口创建线程

   当同此种方法创建线程时，

   1.需要定义类实现Runable接口；

   2.然后覆盖Runable接口中的run()方法；

  3.通过Thread类建立线程对象；

   4.将Runable接口的子类对象作为实际参数传递给Thread类的构造函数；

  5.调用Thread类的start()方法开启线程。

<span style="font-size:14px;">class Ticket implements Runnable
{
	private  int tick = 100;
	public void run()
	{
		while(true)
		{
			if(tick>0)
			{
				System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
			}
		}
	}
}
class  TicketDemo
{
	public static void main(String[] args) 
	{

		Ticket t = new Ticket();

		Thread t1 = new Thread(t);//创建了一个线程；
		Thread t2 = new Thread(t);//创建了一个线程；
		t1.start();
		t2.start();
	}
}</span>

小结：实现Runable方式和继承Thread方式有什么区别呢？

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

两种方式区别：
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable，线程代码存在接口的子类的run方法。

3.获取当前线程对象已经名称

   我们可以获取当前正在运行中的线程对象，并获取线程的名称。

   线程的默认名称为“Thread-编号” 该编号从0开始；特别的是主线程的名称为 “main”

   static Thread currentThread():获取当前线程对象。
   getName(): 获取线程名称。

  可以用setName()来设置线程对象的名称，也可以在创建线程对象的时候通过构造函数来设置线程名称，如下：

   class Test extends Thread
{
    Test(String name)
    {
        super(name);
    }
    public void run()
    {
    }
}

4.多线程的安全问题

   多线程在操作共享数据时，就容易出现安全问题。

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

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

  也就是 同步代码块

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

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

同步的前提：
1，必须要有两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。

利益：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源，

<span style="font-size:14px;">class Ticket implements Runnable
{
	private  int tick = 1000;
	Object obj = new Object();
	public void run()
	{
		while(true)
		{
			synchronized(obj)
			{
				if(tick>0)
				{
					System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
				}
			}
		}
	}
}
class  TicketDemo2
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();

		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
</span>

 实现同步还有一种方式就是 同步函数：

 下面通过买票的程序来介绍，程序中有两个线程，一个使用同步代码块，一个使用同步函数。

<span style="font-size:14px;">class Ticket implements Runnable
{
	private  int tick = 100;
	Object obj = new Object();
	boolean flag = true;
	public  void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(this)  //让同步代码块使用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()  //用synchronized来修饰函数，是函数成为同步函数
	{
		if(tick>0)
		{
			try{Thread.sleep(10);}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);
		}
	}
}
class  ThisLockDemo
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();

		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try{Thread.sleep(10);}catch(Exception e){}
		t.flag = false;
		t2.start();
	}
}</span>

同步函数也需要锁，只是隐式声明而已。

函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。
上面的程序中，同步代码块显示的声明了this锁，程序运行成功，证明了同步函数的锁为this锁。

注意：  当同步函数被Static修饰，就把同步函数定义为静态函数时，由于静态函数存在时，

           内存中并不存在本类对象，即没有this对象，所以静态同步函数的锁并不是this锁，

          但是一定有该类对应的字节码文件对象。
             类名.class  该对象的类型是Class

            在上例中即为Ticket.class，这就是静态同步函数的锁。