黑马程序员----多线程的实现方法和其之间的通信

---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">什么叫做进程？什么又叫做线程?两者有什么区别?</span>

进程：正在行 中的程序 中的程序 。
线程：就是进中一个负责序执行的控制单元 线程：就是进中一个负责序执行的控制单元 线程：就是进中一个负责序执行的控制单元 线程：就是进中一个负责序执行的控制单元。
一个进程中可以多执行路径，称之为线。 一个进程中可以多执行路径，称之为线。 一个进程中可以多执行路径，称之为线。 

开启多个线程是为了同时运行部分代码。 
每一个线程都有自己运行的内容。 这可以称为要执任务每一个线程都有自己运行的内容。 

多线程好处：解决了部分同时运行的问题。
多线程的弊端：使回到效率降低。 

其实应用程序的执行都是 cpucpu 在做着快速的 切换完成在做着快速的切换，这个切换是随机的。 
JVM 启动时就了多个线程，至少有两可以分析的出来。 启动时就了多个线程，

1.main函数里面的线程，具体的韩顺在main函数里面.

2.垃圾回收的线程,保护内存.

class Demo extends Object
{
	public void Test()
	{
		System.out.println("Demo ok");
	}
}
class ThreadDemo 
{
	public static void main(String[] args)
	{
		new Demo();
		new Demo();
		new Demo();
		System.gc();
		System.out.println("Hello World");
	}
}
/*
运行结果:
Hello World
*/

<span style="font-family:Arial, Helvetica, sans-serif;">实现多线程的方法?</span>

一，继承Thread类，复写run()方法，直接创建Thread对象从而创建线程,最后调用start方法.

class Test2 extends Thread
{
	private String name;
	Test2(String name)
	{
		super(name);
		//this.name = name;
	}
	public void run()
	{
		for(int x=0; x<3; x++)
		{
			System.out.println(name+"......x="+x+"......name="+Thread.currentThread().getName());
		}
	}
}
class Demo2
{
	public static void main(String[] args)
	{
		Test2 d1 = new Test2("xiaoming");
		Test2 d2 = new Test2("xiao");
		d1.start();
		d2.start();
		System.out.println("over..."+Thread.currentThread().getName());
	}
}
/*
运行结果:
over...main
null.....x=0......name=xiao
null.....x=1......name=xiao
null.....x=2......name=xiao
null.....x=0......name=xiaoming
null.....x=1......name=xiaoming
null.....x=2......name=xiaoming
*/

二，实现Runnable()接口，复写run()方法，直接创建Thread对象，然后将这个对象当做参数，传入到以接口的父类创建的对象里面，最后调用START方法.

class Test3 implements Runnable
{
	public void run()
	{
		show();
	}
	public void show()
	{
		for(int x=0; x<3; x++)
		{
			System.out.println(Thread.currentThread().getName()+"...."+x);
		}
	}
}
class Demo3
{
	public static void main(String[] args)
	{
		Test3 d = new Test3();
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		t1.start();
		t2.start();
	}
}
/*
运行结果:
Thread-0....0
Thread-1....0
Thread-0....1
Thread-0....2
Thread-1....1
Thread-1....2
*/

<span style="font-family:Arial, Helvetica, sans-serif;">死锁产生的原因?</span>

本质上就是锁的相互嵌套，从而锁死了.

<span style="font-family:Arial, Helvetica, sans-serif;">死锁的解决方法?</span>

synchaonized同步嵌套.

class Test4 implements Runnable
{
	private boolean flag;
	Test4(boolean flag)
	{
		this.flag = flag;
	}
	public void run()
	{
		if(flag)
		{
			while(true)
				synchronized(MyLock.locka)
			{
				System.out.println(Thread.currentThread().getName()+"..if locka...");
				synchronized(MyLock.lockb)
				{
					System.out.println(Thread.currentThread().getName()+"..if lockb...");
				}

			}
		}
		else
		{
			while(true)
			{
				synchronized(MyLock.lockb)
				{
					System.out.println(Thread.currentThread().getName()+"..if lockb...");
					synchronized(MyLock.locka)
					{
						System.out.println(Thread.currentThread().getName()+"..if locka...");
					}
				}
			}
		}
	}

}
class MyLock
{
	public static final Object locka = new Object();
	public static final Object lockb = new Object();
}
class DeadLockTest
{
	public static void main(String[] args)
	{
		Test4 a = new Test4(true);
		Test4 b = new Test4(false);
		Thread t1 = new Thread(a);
		Thread t2 = new Thread(b);
		t1.start();
		t2.start();
	}
}

<span style="font-family:Arial, Helvetica, sans-serif;">线程中的join方法.</span>

class Test5 implements Runnable
{
	public void run()
	{
		for(int x=0; x<50; x++)
		{
			System.out.println(Thread.currentThread().toString()+"...."+x);
			Thread.yield();
		}
	}
}
class JoinDemo
{
	public static void main(String[] args)
	{
		Test5 d = new Test5();
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		t1.start();
		t2.start();
	}
}

<span style="font-family:Arial, Helvetica, sans-serif;">线程之间的通信.</span>

多个线程处理同一个资源，但是任务却不相同.

class  Input implements Runnable
{
	Resource r;
	Input(Resource r)
	{
		this.r = r;
	}
	public void run()
	{
		int x = 0;
		while(true)
		{
			synchronized(r)
			{
				if(x==0)
				{
					r.name = "mike";
					r.sex = "man";
				}
				else
				{
					r.name= "丽丽";
					r.sex = "女";
				}
			}
			x = (x+1)%2;
		}
	}
}
class Output implements Runnable
{
	Resource r;
	Output(Resource r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			synchronized(r)
			{
				System.out.println(r.name+"..."+r.sex);
			}
		}
	}
}
class ResourceDemo
{
	public static void main(String[] args)
	{
		//创建资源
		Resource r = new Resource();
		//创建任务
		Input in = new Input(r);
		Output out = new Output(r);
		//创建线程，执行路径
		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);
		//开启线程
		t1.start();
		t2.start();
	}
}

总结:线程是一个很重要的java的知识点，对于计算机的应用范围很广泛，所以这是一个重点，学习的重点.

---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------