黑马程序员——基础篇——多线程

------- <a  target="blank">android培训</a>、<a  target="blank">java培训</a>、期待与您交流！ ----------

1、创建线程的方式：实现Runnable接口
步骤：
      1）、定义类实现Runnable接口。
      2）、覆盖Runnable接口中的run方法。
      3）、通过Thread类建立线程对象。
      4）、将Runnable接口的子类对象作为实际参数传递给Thead类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数，因为自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。

       5）、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

/**
采用另一种方法创建两个线程，和主线程交替运行
*/
//需要运行的方法创建类实现Thread。
class Test extends Thread
{
        
        Test(String name)
        {
                        super(name);
        }
		//覆写run方法
        public void run()
        {
                
                for(int x = 0; x < 60;x ++)
                {
                        System.out.println("test run..." + x + super.currentThread().getName());
                }
        }
}

class ThreadTest
{
	//主函数
	public static void main(String[] args)
	{
			//创建对象，
			Test t1 = new Test("one");
			Test t2 = new Test("two");
			//调用父类方法，建立两个线程
			t1.start();
			t2.start();
			//主线程
			for(int x = 0; x < 60; x ++)
			{
					System.out.println("main..." + x);
			}
	}
}

2、实现方式和继承方式
         实现方式的好处：避免了单继承的局限性，在定义线程时，建立使用实现方式。
        两种方式的区别：
               继承Thread：线程代码存放Thread子类run方法中；
               实现Runnable;线程代码存在接口的子类的run方法。

3、多线程的安全问题：
           原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。另一个线程参与进来执行，导致共享数据的错误。
          解决办法：对多条操作共享数据的语句，只能让一个线程执行完，在执行过程中，其他线程不可以参与执行。

下面的例子为特殊情况造成的死锁，虽然用了synchronized 但还是造成了死锁，所以应避免设计这样的程序。

/**
死锁例子，
*/
//实现Runnable接口
class Test implements Runnable
{
	private boolean p;
	Test(boolean p)
	{
			this.p = p;
	}
	
	public void run()
	{
		//线程一为真
		if(p)
		{
			//线程一执行
			synchronized(Mylock.locka) //使用锁a
			{
					System.out.println("if locka");//线程一在此处停止去执行线程二
					synchronized(Mylock.lockb)  
					{
							System.out.println("if lockb");
					}
			}
		}
		//线程二为假
		else
		{
			//线程二执行
			synchronized(Mylock.lockb)  //使用锁b，线程一还未使用锁b
			{
					System.out.println("else lockb");
					/*执行结束，锁a被线程一占用无法进入。
					到此处后，线程一启动，但是线程二拿着锁b，线程二拿着锁a，导致死锁*/
					synchronized(Mylock.locka)
					{
							System.out.println("else locka");
					}
			}
		}
	}
}

class Mylock
{
	//创建锁
	static Object locka = new Object();
	static Object lockb = new Object();
}
public class DeadLock
{
	public static void main(String[] args)
	{
		//创建线程
		Thread t1 = new Thread(new Test(true));
		Thread t2 = new Thread(new Test(false));
		//开启线程
		t1.start();
		t2.start();
	}
}

4、Java对于多线程的安全问题提供了专业的解决方式。就是同步代码块。
        Syschronized(对象（可以使用Object类）)
        {
                      需要被同步的代码；
        }
       此处对象为什么必须要建在run函数外部？此对象如同锁，持有锁的线程可以在同步中执行，没有持有锁的线程即使获取cpu的执行权也进不去，因为没有获取锁。
       同步的前提：
      1、必须要有两个或两个以上的线程；
      2、必须是多个线程使用同一个锁；
      3、必须保证同步中只能有一个线程在进行。
好处：解决了多线程的安全问题。

/**
需求：简单的卖票程序。
多个窗口同时卖票

*/
//创建票数的类实现Runnable接口
class Ticket implements Runnable     
{
	private int tick = 100;
	//创建锁
	Object object = new Object();
	public void run()
	{
		//同步代码块
		synchronized(object)
		{
			while(true)
			{
					
				if(tick > 0)
				{
					try{Thread.sleep(10);} catch(Exception e) {}
					System.out.println(Thread.currentThread().getName() + "sale : " + tick--);
				}
					
				if(tick <= 0)
					break;
			}
		}
	}
}

class TicketThread
{
	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();
	}
}

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