当前位置:首页 > 开发 > 编程语言 > 多线程 > 正文

java 线程

发表于: 2013-04-25   作者:chinrui   来源:转载   浏览次数:
摘要: Thread笔记 一、 简单的多线程例子 class Ticket extends Thread { private int tickets = 100; public void run() { while(true) { if(tickets > 0) { System.out.println(Thread.currentThread().g
Thread笔记
一、 简单的多线程例子
class Ticket extends Thread
{
	private int tickets = 100;
	
	public void run() {
		while(true) {
			if(tickets > 0) {
				System.out.println(Thread.currentThread().getName() + "...sales_" + tickets--);
			}
		}
	}
}

public class ThreadDemo_1 
{
	public static void main(String[] args) 
	{
		Ticket t1 = new Ticket();
		Ticket t2 = new Ticket();
		Ticket t3 = new Ticket();
		Ticket t4 = new Ticket();
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

上面的程序将会出现每个线程都卖出100张票的问题
而解决问题的方法有两种:
第一种:在tickets前面加上static使其成为静态的,private static int tickets = 100;
第二种:实现Runnable接口创建线程
class Ticket implements Runnable
{
	private int tickets = 100;
	public void run() {
		while(true) {
			if(tickets > 0) {
				System.out.println(Thread.currentThread().getName() + "...sales_" + tickets--);
			}
		}
	}
}

public class ThreadDemo_3
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

使用实现接口的方式创建线程的好处很多,最重要的是它可以实现线程的同时,继承其它的类,实现多继承的效果。以后的程序中会以实现接口的方式为主。
二、 上面的程序虽然解决了问题,但还有隐藏的问题存在。例如,如果在判断语句if(tickets > 0)之后,加上sleep()方法则会出现有线程卖出票号为负的问题。原因在此不做解释,分析可得。
class Ticket implements Runnable
{
	private int tickets = 100;
	
	public void run() {
		while(true) {
			if(tickets > 0) {
				try	{
					Thread.sleep(10);
				}
				catch (InterruptedException e){
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "...sales_" + tickets--);
			}
		}
	}
}

程序运行的结果(最后面):
Thread-0...sales_0
Thread-3...sales_-1
Thread-1...sales_-2
三、 为解决上述问题,修改类如下:
class Ticket implements Runnable
{
	private int tickets = 100;
	Object object = new Object();
	public void run() {
		while(true) {
			synchronized(object) {
				if(tickets > 0) {
					try	{
						Thread.sleep(10);
					}
					catch (InterruptedException e){
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "...sales_" + tickets--);
				}
			}
		}
	}
}

锁定成员变量,使得在一段时间内只有一个线程能够访问到共用的成员变量。
第二种锁定方法:不能直接锁定run()方法,要不然只有第一个线程能够访问run方法,而且里面是无限循环,也就是说只有一个线程在卖票,而其余的线程没能起到相应的作用。
class Ticket implements Runnable
{
	private int tickets = 100;
	Object object = new Object();
	public void run() {
		while(true) {
			show();
		}
	}
	public synchronized void show() {
		if(tickets > 0) {
			try	{
				Thread.sleep(10);
			}
			catch (InterruptedException e){
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "...sales_" + tickets--);
		}	
	}
}

四、 由上述程序我们可以看到,synchronized()方法的参数(即锁)是任一对象,那我们对方法进行锁定的时候,没有指明锁是哪个,那么默认的锁是哪个呢?默认的锁是this,下面我们使用程序进行验证。
class Ticket implements Runnable
{
	private int tickets = 100;
	Object obj = new Object();
	boolean flat = true;
	public void run() {
		if(flat) {
			while(true) {
				synchronized(obj) {
					if(tickets > 0) {
						try{Thread.sleep(10);}catch(Exception e){}
						System.out.println(Thread.currentThread().getName() + "...sales..." + tickets--);
					}
				}
			}
		} else { show(); }
	}
	public synchronized void show() {
		while(true) {
			if(tickets > 0) {
				try{Thread.sleep(10);}catch(Exception e){}
				System.out.println(Thread.currentThread().getName() + "...show_" + tickets--);
			}
		}
	}
}

public class ThisLockDemo
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try{Thread.sleep(10);}catch (Exception e){}
		t.flat = false;
		t2.start();
	}
}

使用两个线程进行售票,但将两个线程分开进行执行,当不使用默认锁的时候,我们可以得到的运行结果是:
Thread-1...show_3
Thread-0...sales...2
Thread-1...show_1
Thread-0...sales...0
可以看出其售出了0号票,可以我们已经加锁了,怎么会这样呢,因为使用的是两个不同的锁,所以会出现问题,如果我们将,非默认的锁改成this则会得到输出结果为:
Thread-1...show_4
Thread-1...show_3
Thread-1...show_2
Thread-1...show_1
没有出现0号票,使用的是同一个锁,所以证明,没有指定锁对象的时候,使用的是this对象。
五、 如果同步的方法是静态的,那么它使用的锁对象又是谁呢?由于静态方法中,是没有this对象的,而只有一个类的字节码文件对象,因此我们猜此时的锁对象就是它的字节码文件对象,下面我们使用程序进行验证:
将Ticket类修改如下,使show()方法变成静态方法:
class Ticket implements Runnable
{
	private static int tickets = 100;
	boolean flat = true;
	public void run() {
		if(flat) {
			while(true) {
				synchronized(this) {
					if(tickets > 0) {
						try{Thread.sleep(10);}catch(Exception e){}
						System.out.println(Thread.currentThread().getName() + "...sales..." + tickets--);
					}
				}
			}
		} else { show(); }
	}
	public static synchronized void show() {
		while(true) {
			if(tickets > 0) {
				try{Thread.sleep(10);}catch(Exception e){}
				System.out.println(Thread.currentThread().getName() + "...show_" + tickets--);
			}
		}
	}
}

则我们得到程序的运行结果:
Thread-1...show_3
Thread-0...sales...2
Thread-1...show_1
Thread-0...sales...0
又出现了0号票,因此静态方法的锁对象不是this对象。下面验证其锁对象为方法所在类的字节码文件对象,此时我们将this修改为Thicket.class进行实验,得到运行结果:
Thread-0...sales...4
Thread-0...sales...3
Thread-0...sales...2
Thread-0...sales...1
由此可以验证,静态方法使用的锁对象是方法所在类的字节码文件对象。
六、 死锁程序
class Test implements Runnable
{
	//定义布尔变量flag,对线程进行判断,让其执行相应的代码块
	private boolean flag;
	public Test(boolean flag) {
		this.flag = flag;
	}
	//使用两个锁对象,对两个代码块都进行锁定,而且是相互锁定
	public void run() {
		//根据线程的布尔属性执行不同的代码块
		//两个锁对象是相互嵌套的
		if(flag) {
			synchronized(DeadLockTest.locka) {
				System.out.println("if locka");
				synchronized(DeadLockTest.lockb) {
					System.out.println("if lockb");
				}
			}
		} else {
			synchronized(DeadLockTest.lockb) {
				System.out.println("else lockb");
				synchronized(DeadLockTest.locka) {
					System.out.println("else locka");
				}
			}
		}
	}
}

public class DeadLockTest 
{
	static Object locka = new Object();
	static Object lockb = new Object();
	public static void main(String[] args) 
	{
		//建立两个布尔属性不一样的线程,并启动
		Thread t1 = new Thread(new Test(true));
		Thread t2 = new Thread(new Test(false));
		t1.start();
		t2.start();
	}
}

/******************************对死锁的程序要理解透彻**************************************/
七、 加锁使线程同步时要注意的三个条件
第一、 多个线程
第二、 操作同一对象
第三、 使用同一个锁
八、 线程间的通讯(设置一个人的属性读一个人)
class People
{
	private String name;
	private String sex;
	boolean flag = false;
	public synchronized void set(String name, String sex) {
		if(flag)
			try{this.wait();}catch(InterruptedException e) {}
		this.name = name;
		this.sex = sex;
		flag = true;
		this.notify();
	}
	public synchronized void out() {
		if(!flag)
			try{this.wait();}catch(InterruptedException e) {}
		System.out.println(name + "..." + sex);
		flag = false;
		this.notify();
	}
}

class Input implements Runnable
{
	private People p;
	public Input(People p) {
		this.p = p;
	}
	int i = 0;
	public void run() {
		while(true) {				
			if(i == 0) {
				p.set("nike","male");
			} else {
				p.set("丽丽","女");
			}
			i = (i+1)%2;				
		}
	}
}

class Output implements Runnable
{
	private People p;
	public Output(People p) {
		this.p = p;
	}
	public void run() {
		while(true) {
			p.out();
		}
	}
}

public class InputOutputDemo_2
{
	public static void main(String[] args) 
	{
		People p = new People();
		new Thread(new Input(p)).start();
		new Thread(new Output(p)).start();
	}
}

九、 当出现两个以上的生产者和消费者时,我们需要使用while进行判断,且使用notifyAll()唤醒所有线程
class Product
{
	private String name = "";
	private int count = 0;
	boolean flag = false;
	public synchronized void set(String name) {
		while(flag) //*********
			try{this.wait();}catch(InterruptedException e) {}
		this.name = name + "..." + count++;
		System.out.println(Thread.currentThread().getName() + "...生产者" + this.name);
		flag = true;
		this.notifyAll();
	}
	public synchronized void out() {
		while(!flag)//********
			try{this.wait();}catch(InterruptedException e) {} 
		System.out.println(Thread.currentThread().getName() + "...消费者......" + this.name);
		flag = false;
		this.notifyAll();
	}
}

class Producer implements Runnable
{
	private Product pro;
	public Producer(Product pro) {
		this.pro = pro;
	}
	public void run() {
		while(true) {
			pro.set("商品");
		}
	}
}

class Consumer implements Runnable
{
	private Product pro;
	public Consumer(Product pro) {
		this.pro = pro;
	}
	public void run() {
		while(true) {
			pro.out();
		}
	}
}

class ProducerConsumerTest  
{
	public static void main(String[] args) 
	{
		Product pro = new Product();
		Producer p = new Producer(pro);
		Consumer c = new Consumer(pro);
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(p);
		Thread t3 = new Thread(c);
		Thread t4 = new Thread(c);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

十、 线程间的通信、
JDK1.5的新特性:提供了多线程升级解决方案,将同步synchronized替换成现实Lock操作,将Object中的wait,notify,notifyAll等方法替换成Condition对象,该对象可以通过Lock锁进行获取,可以实现只唤醒对方的操作,不过解锁的动作必须要完成,也就是用finally包括。

java 线程

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
一、什么是线程 线程是指令的执行路径。在Java语言中,线程无处不在,每一个计算机程序最少都有一个
一、什么是线程 线程是指令的执行路径。在Java语言中,线程无处不在,每一个计算机程序最少都有一个
线程的概念: 几乎每种操作系统都支持进程的概念 ----进程就是在某种程度上互相隔离的、独立运行的程
线程有自己的状态,除了新建和死亡状态,还有 等待/阻塞 、准备 、和运行 状态。 线程状态的转换是
线程的实现   1.使用内核线程实现   内核线程(KLT)就是直接由操作系统内核支持的线程,这种线
1.线程的定义 a.扩展java.lang.Thread类 /** * 测试扩展Thread类实现的多线程程序 * * @author */ p
1.线程的创建:(两种方法) 1)继承Thread类,重写里面的run方法,将要运行的代码放在run方法中 2
1.线程的状态 1.1:yield()让出CPU资源 1.2:sleep是thread类的方法;不释放锁;自动苏醒;任意地方
先说说线程和进程,现代操作系统几乎无一例外地采用进程的概念,进程之间基本上可以认为是相互独立
Java线程:概念与原理 SCJP5学习笔记 一、操作系统中线程和进程的概念 现在的操作系统是多任务操作
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号