【黑马程序员】java中-------------多线程Thread类

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

 

一、线程

进程的定义：是一个正在执行中的程序，每一个进程执行度有一个执行顺序，该顺序是一个执行路径或者叫一个控制单元

线程的定义：就是进程中的一个独立的控制单元，线程在控制着进程的执行

      一个进程至少有一个进程

创建线程的第一种方式：

  继承Thread类，复写run方法，调用线程的start（）方法；run方法中存放着线程要执行的代码

二、多线程存在的意义

1、比如我们开启jvm，执行某段代码，器他里面包含两条线程控制着，其中main函数由一条线程控制着，依次执行代码。

   二第二条线程则控制着虚拟机的垃圾回收器。只有内存中产生垃圾，这个线程就会启动，负责会垃圾（所谓的垃圾回收）

   多线程不就可以提高程序运行的效率，而且可以可以提高性能

2、比如说我们生活中，多窗口火车售票系统，就是应用到了多线程，多个窗口同时共享同一个售票系统中的票。

单线程是无法做到的

三、线程的运行状态：5种

四、创建线程

1、java中已经提供了操作线程的类：thread类

2、创建线程有两种方式，

a、第一种方式，自定义一个类extends继承thread类，并复写父类中run（）方法

class Test extends Thread{
	
	public void run(){
		for(int x=0;x<15;x++){
			System.out.println(Test.currentThread().getName()+"目标");
		}
	}
}
class ThreadTest1{
	public static void main(String[] args){
		Test t1=new Test();
		Test t2=new Test();
		t1.start();
		t2.start();

/*卖票程序---第一种方式：继承Thread类复写run方法*/

class Ticket implements Runnable{
	private int ticket=100;
	public void run(){
		while (ticket>0){
			try
			{
				Thread.sleep(10);
			}catch(Exception e){}
			
			System.out.println(Thread.currentThread().getName()+"--------"+ticket--);
		}
	}
}
class TicketDemo{
	public static void main(String[] args){
		Ticket ti=new Ticket();
		Thread t1=new Thread(ti);
		Thread t2=new Thread(ti);
		Thread t3=new Thread(ti);
		Thread t4=new Thread(ti);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

创建线程的第二种方式：

实现Runnable接口，覆盖run方法。

并且将Runnable接口的子类对象作为参数传递给Thread线程对象

调用start（）方法开启线程

继承与实现的区别：

利：避免了单继承的局限性

1.继承Thread类，线程代码存放在Thread子类的run方法中

2.实现Runnable接口，线程代码存放在接口的子类的run()方法中

/*z在使用线程时：建议使用implements实现Runnable接口，复写run方法
因为java支持单继承，多实现
*
class ThreadTest{
	public static void main(String[] args){
	
		Ticket t=new Ticket();
		Thread t1=new Thread(t);
		Thread t2=new Thread(t);
		t1.start();
		t2.start();
		
	}
}
class Ticket implements Runnable{
	private int tick=100;
	Object obj=new Object();
	public void run(){
		while(true){
		  synchronized(obj){
		      try{Thread.sleep(5);}
		      
		      catch(Exception e){}
			 if(tick>0){
			     System.out.println(Thread.currentThread().getName()+"价值"+tick--);
			  }	
		   }
		}
	}
}

线程安全问题：

利用同步锁机制：synzhronized
同步代码块和同步函数
利：解决了多线程的安全问题
弊：较为耗费资源

/*在银行，两个储户在给同一个账户 存钱，每个人存300元，每次各存100*/
class Bank{
	private int sum;
	public synchronized void add(int n){
		sum=sum+n;
		try{
			Thread.sleep(10);
		}
		catch(Exception e){
			System.out.println("交易失败");
		}
		System.out.println("sum"+sum);
	}
}
class Cus implements Runnable{
	private Bank b=new Bank();
	public void run(){
		for(int x=0;x<3;x++){
			b.add(100);
		}
	}
}
class BankDemo{
	public static void main(String[] args){
		Cus c=new Cus();
		Thread t1=new Thread(c);
		Thread t2=new Thread(c);
		t1.start();
		t2.start();
	}
}

jdk1.5中，提供了多线程升级的解决方案：

   将同步synchronized替换成实现Lock操作，将Object中的wait,  notify,  notifyAll替换成Condition对象
   通过建立Lock接口的子类（RiintreantLock）对象,newCondition()方法获取Condition对象
   使用Condition对象中的保证相册同步的方法：await(); signal();   signalAll();

 例子：生产者与消费者

 

/*生产者，消费者练习
jdk1.5新特性：java.util.concurrent.lock包中
接口Lock ：lock();  unlock()f方法  已替代了synchronized函数和synchronized代码块
接口Condition :awit();  signal();  signalAll()方法已替代wit();  notify();  notifyAll()方法
*/
import java.util.concurrent.locks.*;
class GonChan{
	private String name;
	
	private int count=1;
	private boolean flag=false;
	private Lock lock=new ReentrantLock();
	
	
	private Condition condition_s=lock.newCondition();
	private Condition condition_x=lock.newCondition();

	
	public void set(String name)throws InterruptedException{
		lock.lock();
		
		try{
			while(flag)
				condition_s.await();
			this.name=name+"---"+count++;
			System.out.println(Thread.currentThread().getName()+"-----生产者-----"+this.name);
			flag=true;
			condition_x.signal();
			}
			finally{
				lock.unlock();
			}
	}
	public void out()throws InterruptedException
	{
		lock.lock();
		
		try{
			while(!flag)
				condition_x.await();
			System.out.println(Thread.currentThread().getName()+"-------------------消费者-----"+this.name);
			flag=false;
			condition_s.signal();
			
		}finally{
			lock.unlock();
		}
	}
}
class Sheng implements Runnable{
	private GonChan g;
	Sheng(GonChan g){
		this.g=g;
	}
	public void run(){
		while(true)
			try{
				g.set("商品");
			}
			catch(Exception e){}
	}
}
class Xiao implements Runnable{
	private GonChan g;
	Xiao(GonChan g){
		this.g=g;
	}
	public void run(){
		while(true)
			try{
				g.out();
			}
			catch(Exception e){}
	}
}
class ShengXiaoDemo{
	public static void main(String[] args ){
		GonChan gc=new GonChan();
		Sheng sh=new Sheng(gc);
		Xiao xi=new Xiao(gc);
		
		new Thread(sh).start();
		new Thread(xi).start();
		
	}
}

Thread类中的方法：
/ intrttupt(); (清除线程状态)   抛异常：InterruptException
/  setDaemon(boolean on)   守护线程
/ join() 等待该线程停止
/ yield()   用于临时释放执行权，使得线程执行的很平均
/ setPriority(int newPriority)更改线程的优先级