黑马程序员_Java线程

------- android培训、java培训、期待与您交流！ ----------

多线程：

在一个程序内部也可以实现多个任务并发执行,其中每个任务称为线程。
创建线程：
1.继承Thread类。
步骤：
1.继承Thread类。
2.覆写run（）方法。（run用于存储线程要运行的代码，所以需要复写）
3.调用线程的strat()方法：1.启动线程。2.调用run方法。
实现：

package com.dmm.javase;
class Demo extends Thread{
	public void run() {
		System.out.println("运行线程");
	}
}
public class ThreadTest {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Demo d = new Demo();
		d.start();
	}


}

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

package com.dmm.javase;
class Demo implements Runnable {
	private int tick = 100;
	
	public void run() {
		while(true){
			if (tick > 0) {
				System.out.println(Thread.currentThread().getName() + "-----sale: " + tick--);
			}
		}
		
	}
}
public class ThreadTest {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Demo d = new Demo();
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		Thread t3 = new Thread(d);
		Thread t4 = new Thread(d);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		


	}
}

总结：建议开发中使用实现接口方式，避免单继承的局限性。可以多实现。


线程的运行状态:
用new运算符和Thread类或其子类建立一个线程对象后，该线程就处于新生状态。
   新生--->就绪:通过调用start()方法
   就绪--->运行:处于就绪状态的线程一旦得到CPU，就进入运行状态并自动调用自己的run()方法
   运行--->阻塞:处于运行状态的线程,执行sleep()方法，或等待I/O设备资源，让出CPU并暂时中止自己运行，进入阻塞状态
   阻塞--->就绪:睡眠时间已到,或等待的I/O设备空闲下来，线程便进入就绪状态，重新到就绪队列中等待CPU。当再次获得CPU时，便从原来中止位置开始继续运行。
   运行--->死亡:(1)(正常情况下)线程任务完成
                (2)(非正常状况)线程被强制性的中止,如通过执行stop()或destroy()方法来终止一个线程
                
线程的安全性:
当多条语句在操作同一个线程共享数据时，一个线程对多调语句只执行了一部分，还没有执行完。
另一个线程参与进来执行，导致共享数据错误。


解决办法：对多条操作共享的语句，只能让一个线程执行完，执行过程中其他线程不参与。
1.同步代码块：

synchronized（对象）{

需要被同步的代码

}
好处：解决线程的安全问题
弊端：都会判断同步锁，降低效率
使用前提：1.必须是两个或者两个以上的线程。
 2.多个线程使用同一个锁
2.同步函数

class Bank implements Runnable {
	private int sum;
	private Object obj = new Object();


	public void add(int num) {
		synchronized (obj) {
			sum += num;		
			System.out.println("sum=" + sum);
		}
	}


	public void run() {
		for (int i = 0; i <= 3; i++) {
			add(100);
		}
	}
}


/*add函数中存在同步代码块,可直接改写为同步函数,Object对象可以删除*/


public synchronized void add(int num) {
	sum += num;	
	System.out.println("sum=" + sum);
}

2.同步函数设置在run函数上，会被某个线程一直占用，直到它执行结束，其他线程才能得到处理权
3.同步代码块和同步函数区别
同步代码块的锁是任意的对象，同步函数的锁是this


4.静态同步函数的锁
使用的锁是该方法所在类的字节码文件对象，类名.class或this.getClass()
(字节码文件对象：JVM在加载某个.class文件之后得到的一段字节？？还是就是.class本身？)


5.死锁
是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。


简单演示

package lock;


public class Demo {
	public static void main(String[] args) {
		LockDemo d1=new LockDemo(true);
		LockDemo d2=new LockDemo(false);		
		Thread t1=new Thread(d1);
		Thread t2=new Thread(d2);
		t1.start();
		t2.start();
	}
}


class LockDemo implements Runnable
{
	private boolean flag;
	LockDemo(boolean flag){
		this.flag=flag;
	}
	public void run(){
		if(flag)
		{
			synchronized(Lock.lockA)
			{
				System.out.println("true lockA");
				synchronized(Lock.lockB)
				{
					System.out.println("true lockB");
				}
			}
			System.out.println("true over");
		}
		else
		{
			synchronized(Lock.lockB)
			{
				System.out.println("false lockB");
				synchronized(Lock.lockA)
				{
					System.out.println("false lockA");
				}
			}
			System.out.println("false over");
		}
	}
}


class Lock
{
	public static final Object lockA=new Object();
	public static final Object lockB=new Object();
}

------- android培训、java培训、期待与您交流！ ----------