---------------------- <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)更改线程的优先级