黑马程序员——java学习之多线程处理

                     ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

     经过一天的学习，重新把握了一下多线程的知识，这块知识很重要，但是有固定的格式，并不复杂，只要还是运用方面吧，之前对这块有所了解，但是也有不足，这次重新学习之后，应该算是有所提高，也重新对一些小的知识点进行了总结。
多线程：

    创建方式，自定义一个线程（控制单元）：1：将类声明为Thread子类。该子类要重写Thread类的run方法。

步骤：1，定义类继承Thread。2，复写Thread类run方法3，调用线程的start方法。d.start();

    为什么要重写run方法：   建立好一个对象就创建好一个线程。run方法用于存储线程要运行的代码。主线程在main方法中存储主线程的运行代码。   Thread t = new Thread（）t.start。    没有运行的代码，所以只能继承Thread类，并复写run方法，用于定义线程要运行的代码。

    多线程示例：

class Demo extends Thread{

public void run（）{

System.out.println("Demo run");

}

}  main（）{

Demo d = new Demo；d.start();//开启现成，并调用run方法。}/*d.run()。没有启动线程。只是封装代码。*/    start很重要。

    特性：随机性，多线程的运行行为可以看作是向相互抢夺cpu资源。

    线程运行的状态：创建，运行，冻结（没有执行资格），消亡，临时状态（具备运行资格，没有执行权）。sleep（时间），wait（）---notify（），stop（）。

    线程都有自己的默认名称，为Thread0，1，2。getName（）。   currentThread（）：获取当前线程对象。

    不同线程共享一个数据时，卖票的例子，当只有一个线程对象时，线程只能运行一次，否则会出现运行异常的问题，这时就要考虑第二种线程创建的方式。

    第二种方式为：实现Runnable接口。步骤：1， 定义类实现Runnable接口。implements Runnable。2，覆盖Runnable的Run方法。 3，通过Thread类建立线程对象。4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。//让线程指定指定对象的run方法。5，调用Thread类的start方法，开启线程，并调用run方法。

    ###重点---实现方式与继承方式的区别：线程代码存放的位置不同。继承方式存在在Thread子类run方法中。实现方式存放在接口的子类的run方法中。

    一般情况下使用实现方式。

格式为：class Demo iplements Runnable{

public void run（）{

}

}

mian（）{

Demo d = new Demo（）；  Thread t1 = new Thread（d）； Thread t2 =new Thread（d）； t1.start；t2.start;

}

以上为两种不同线程的创建方式

多线程的安全问题：

    sleep  接口异常不能抛异常。  sleep是静态的方法。Thread.sleep()要try，catch。

    当线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来，导致共享数据的错误。 解决办法：对多条操作共享数据的语句，让一个线程都执行完前，其他线程不可以参与`运行。

    java对此提供了专业的解决办法。同步代码块。格式为 Synchronized（对象）{需要同步的代码块}

    Synchronized对象表示同步锁。

    解决安全为题的前提：1，必须有两个或者两个以上的线程。2，必须是多个线程使用同一个锁。

    好处：解决了多线程的安全问题。但是弊端是消耗资源。（判断锁）。

    多线程--同步函数：把synchronized放在函数上做为修饰符就可以了。搞清那些需要同步。

    同步函数的锁是this。

    函数可以用静态修饰，同步函数被静态修饰后，使用的锁不是this，又不安全了，静态方法中不可以定义this，锁就是class。

静态进内存是没有本类对象，由类调用。先封装成class对象。所以内存中有一个字节码文件对象，这个对象就是类名.class。

死锁：同步中嵌套同步，但是锁却不同。

下面是参照老师写的死锁的程序：

class Test implements Runnable
{
	private boolean flag;
	Test(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()+"..else lockb");
					synchronized(MyLock.locka)
					{
						System.out.println(Thread.currentThread().getName()+".....else locka");
					}
				}
			}
		}
	}
}


class MyLock
{
	static Object locka = new Object();
	static Object lockb = new Object();
}

class  DeadLockTest
{
	public static void main(String[] args) 
	{
		Thread t1 = new Thread(new Test(true));
		Thread t2 = new Thread(new Test(false));
		t1.start();
		t2.start();
	}
}

后续知识点：

   wait notify要用在同步里，锁.wait（）。  锁.notify（）。要标示锁。还要处理异常，try  catch。

lock   jdk5.0新特性： lock.lock(); finally{lock.unlock();}//释放锁的动作一定要执行。

condition.await()抛出InterruptedException    condition.signal() 

   新特性的好处是不是唤醒所有，可以只唤醒对方。

   wait，notify，notifyAll是object中的方法。、

   多线程一般都是循环结构，只要控制循环，就可以结束run线程。

   Thread类提供一个interrupt（）方法，让线程结束，恢复到运行状态上来。

   setDaemon()守护线程，布尔型。在线程调用前调用。

   join方法： 运算完别人才能执行。临时加入线程执行。

   优先级一共10，默认5。setPriority（int 。。。）max min  more默认优先级。

   yield表示临时停止。

      明天继续学习java中的集合问题，这块比较繁琐，很多东西搞不清真个集合就等于没学。所以要做好心理准备，再接再厉。

多线程：

创建方式，自定义一个线程（控制单元）：1：将类声明为Thread子类。该子类要重写Thread类的run方法。

步骤：1，定义类继承Thread。2，复写Thread类run方法3，调用线程的start方法。d.start();

为什么要重写run方法：   建立好一个对象就创建好一个线程。run方法用于存储线程要运行的代码。主线程在main方法中存储主线程的运行代码。   Thread t = new Thread（）t.start。    没有运行的代码，所以只能继承Thread类，并复写run方法，用于定义线程要运行的代码。

多线程示例：

class Demo extends Thread{

public void run（）{

System.out.println("Demo run");

}

}  main（）{

Demo d = new Demo；d.start();//开启现成，并调用run方法。 }/*d.run()。没有启动线程。只是封装代码。*/    start很重要。

特性：随机性，多线程的运行行为可以看作是向相互抢夺cpu资源。

线程运行的状态：创建，运行，冻结（没有执行资格），消亡，临时状态（具备运行资格，没有执行权）。sleep（时间），wait（）---notify（），stop（）。

线程都有自己的默认名称，为Thread0，1，2。getName（）。   currentThread（）：获取当前线程对象。

不同线程共享一个数据时，卖票的例子，当只有一个线程对象时，线程只能运行一次，否则会出现运行异常的问题，这时就要考虑第二种线程创建的方式。

第二种方式为：实现Runnable接口。步骤：1， 定义类实现Runnable接口。implements Runnable。2，覆盖Runnable的Run方法。

3，通过Thread类建立线程对象。4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。//让线程指定指定对象的run方法。5，调用Thread类的start方法，开启线程，并调用run方法。

###重点---实现方式与继承方式的区别：线程代码存放的位置不同。继承方式存在在Thread子类run方法中。实现方式存放在接口的子类的run方法中。

一般情况下使用实现方式。

格式为：class Demo iplements Runnable{

public void run（）{

}

}

mian（）{

Demo d = new Demo（）；  Thread t1 = new Thread（d）； Thread t2 =new Thread（d）； t1.start；t2.start;

}

以上为两种不同线程的创建方式

多线程的安全问题：

sleep  接口异常不能抛异常。  sleep是静态的方法。Thread.sleep()要try，catch。

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

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

java对此提供了专业的解决办法。同步代码块。格式为 Synchronized（对象）{需要同步的代码块}

Synchronized对象表示同步锁。

解决安全为题的前提：1，必须有两个或者两个以上的线程。2，必须是多个线程使用同一个锁。

好处：解决了多线程的安全问题。但是弊端是消耗资源。（判断锁）。

多线程--同步函数：把synchronized放在函数上做为修饰符就可以了。 搞清那些需要同步。

同步函数的锁是this。

函数可以用静态修饰，同步函数被静态修饰后，使用的锁不是this，又不安全了，静态方法中不可以定义this，锁就是class。

静态进内存是没有本类对象，由类调用。先封装成class对象。所以内存中有一个字节码文件对象，这个对象就是类名.class。

死锁：同步中嵌套同步，但是锁却不同。

死锁的程序：

wait notify要用在同步里，锁.wait（）。  锁.notify（）。要标示锁。还要处理异常，try  catch。

lock   jdk5.0新特性： lock.lock(); finally{lock.unlock();}//释放锁的动作一定要执行。

condition.await()抛出InterruptedException    condition.signal()

新特性的好处是不是唤醒所有，可以只唤醒对方。

wait，notify，notifyAll是object中的方法。、

多线程一般都是循环结构，只要控制循环，就可以结束run线程。

Thread类提供一个interrupt（）方法，让线程结束，恢复到运行状态上来。

setDaemon()守护线程，布尔型。在线程调用前调用。

join方法： 运算完别人才能执行。临时加入线程执行。

优先级一共10，默认5。setPriority（int 。。。）max min  more默认优先级。

yield表示临时停止，