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

线程总结

发表于: 2014-07-16   作者:肆无忌惮_   来源:转载   浏览:
摘要: 一、程序,进程,线程的区别        程序是一段静态的代码,是软件执行的蓝本。        进程可以理解为正在进行的程序,它是从程序加载、执行、执行完毕的整个过程,多个进程可以共享操作系统所管理的资源,比如剪切板。每个进程都单独占用一块内存,多个进程之间不能数据共享,必须通过网络交换数据。   &

一、程序,进程,线程的区别

       程序是一段静态的代码,是软件执行的蓝本。

       进程可以理解为正在进行的程序,它是从程序加载、执行、执行完毕的整个过程,多个进程可以共享操作系统所管理的资源,比如剪切板。每个进程都单独占用一块内存,多个进程之间不能数据共享,必须通过网络交换数据。

       线程是比进程更小的执行单位,一个进程在执行过程中,可以产生多个线程。线程是一个进程内部的多个并行的运行单元,同一个进程的多个线程之间可以通过内存共享数据。通俗地讲,线程是运行在进程中的小“进程”。

 

二、Java中的多线程

       Java程序执行时,先启动了一个主线程,即main方法。在main方法中,可以开启其他线程。当main方法执行完毕的时候,程序不会退出,只有所有线程都执行完毕,Java程序才会退出。

       线程的使用方法:

       1.继承Thread类

       

public class A extends Thread{
	public void run(){
		//线程要干的活...
	}
}

class Main{
         public static void main(String args[]){
                    new A().start();//这样就执行了A中的run方法,当run执行完毕,线程结束

          }

}

 

 

       2.实现Runnable接口

 

 

/**
 *刷新Jpanel的线程
 *
 **/

public class UpdataCenter implements Runnable {

	JPanel center;

	public UpdataCenter(JPanel center) {
		this.center = center;
	}

	@Override
	public void run() {
		while (true) {
			if (!MainUI.pause) {
				center.repaint();
			}
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

//调用
UpdataCenter st = new UpdataCenter(center);
		Thread th = new Thread(st);
		th.start();//开启线程

 

 

         当有多个线程执行的时候,由于CPU每次只处理一个,他们的处理顺序是不确定的,所以先开启的线程不一定先执行。

 

        当run方法执行完毕,线程变成死亡状态,释放了分配给线程对象的内存。如果在run未执行完重复调用start()会抛出IlIegalThreadStateException。

 

三、线程中的方法

       sleep(long a);休眠a毫秒,再往下执行。

       interrupt()可以吵醒休眠的线程,结束休眠。

       isAlive();线程在执行run的过程中返回true,开始执行前和执行结束后返回false。

 

四、线程同步

        同步:有多个线程同时操作一个变量,这个时候就没办法确定程序的正确性了,所以应该想办法解决这种 同时执行的时候对变量改变的不确定性,所以得先执行玩这个再执行其它,同时只做一件事。

        异步:多线程可以同时操作,不会发生结果错误。、

 

        比如在两个地方同时使用网银转账。本来银行卡剩余1000,在A处转出800,在B处转出500.最后本来卡内余额应该为-300。但是由于使用两个线程在同时取钱,这就造成了结果的不确定性。

 

线程A处从内存中读到money = 1000;对其进行-800的操作,money = 200;

线程B处从内存中读到money = 1000;对其进行-500的操作,money = 500;

两个线程计算完毕,将数据放回原地,而Cpu只能一次一次的放(同时只能处理一件事,只是速度非常快)CPU有可能先将200放回去,再将500放回去,那么卡内余额变成了500(200被覆盖),反之亦然。

 

       当然,还有一种情况是,线程A处从内存中读到money = 1000;对其进行-800的操作,money = 200,将其放回原地;在进行B的操作(线程执行顺序具有不确定性)。这个时候卡内余额变成了-300。

 

       如何避免第一种情况的发生?这就是线程同步需要处理的问题。

 

       Java中提供了关键字synchronized(同步),使用该关键字可以修饰方法,对象。

使用它修饰之后,当一个线程取出了这个对象对其修改或者这个方法对其执行。其余线程必须等待它先执行完毕。这样就避免了第一种错误。

 

       使用方法:

 

public class Main {
	public static void main(String[] args) {
		Account ac = new Account();
		new Card(ac, 800).start();
		new Card(ac, 400).start();
		
	}
}

package Thread20140715;

public class Card extends Thread {

	Account ac;
	int n;

	public Card(Account ac, int n) {
		this.ac = ac;
		this.n = n;
	}

	/**
	 * 异步:可以同时修改这块内存,导致结果出错。
	 * 
	 * 如果没在Account锁定,
	 * 
	 * 输出结果:-200 -200或者200 200或者600 600
	 * 
	 * 否则,结果为 200/600 -200
	 */
	public void run() {
		ac.getMoney(n);
		ac.getMoney1(n);
		ac.getMoney2(n);
	}

	/**
	 * 同步:只允许一个Account操作修改这块内存。
	 * 
	 * 输出结果: 200/600 -200
	 */
	// public void run() {
	// synchronized (ac) {// 锁定ac
	// ac.getMoney(n);
	// }
	// }

}

package Thread20140715;

public class Account {

	int money = 1000, money1 = 1000, money2 = 1000;

	/**
	 * 异步
	 * 
	 * @param n
	 *            要取多少钱
	 */
	public void getMoney1(int n) {
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		money1 -= n;
		System.out.println("剩余金额1:" + money1);
	}

	/**
	 * 同步
	 * 
	 * @param n
	 *            要取多少钱
	 */
	public void getMoney2(int n) {
		synchronized (this) {// 锁定this对象,所有属性不可修改
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			money2 -= n;
			System.out.println("剩余金额2:" + money2);
		}
	}

	/**
	 * 同步
	 * 
	 * @param n
	 *            要取多少钱
	 */
	public synchronized void getMoney(int n) {
		// 锁定方法,此时不锁定属性,
		// 所以其它方法仍然可对money进行修改,导致结果出错

		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		money -= n;
		System.out.println("剩余金额:" + money);

	}
}

输出结果:
剩余金额:200
剩余金额1:600
剩余金额:-200
剩余金额2:200
剩余金额1:600
剩余金额2:-200

由结果可知,剩余金额1是错误的结果,因为1没有使用同步(这个结果很随机,但是只有1可能错误)。

 

五、锁

用来锁定中间的代码。

        Lock lc = new ReentrantLock();

lc.lock();

        ……

lc.unlock();

 

六、计时器线程

       使用方法:创建Timer计时器对象,创建相应任务。调用schedule方法。传入任务,第一次执行延长的时间,以后执行的周期。

       Timer timer = new Timer();

       EnermyPlaneCreator task = new EnermyPlaneCreator();

       timer.schedule(task, 800, 20000);

 

       public class EnermyPlaneCreator extends TimerTask{

              public void run() {}

       }

 

七、线程使用模型

1.监听器模型

在A线程中增加标记flag,在B线程中对A中的flag进行操作。B为A的监听线程。

例如:flag初始值为0,表示A没开始执行。当A start之后,将flag赋值为1,这时B就可以知道此时A已经开始执行了。当A执行到某个操作,flag=2,这是B也可以知道A执行到哪里了。

 

2.生产消费模型

开启一个生产者线程A,一个消费者线程B。

在A中生成对象,在B中消费对象。(例如ArrayList的add,remove操作)

由于线程的执行顺序不确定,这个时候A可能还没有生成,B就去消费了。程序就会有问题。

可以进行判断,当消费的时候判断是否已经有了生成,如果没有生产,就通知生产者进行生产并等待生产者进行生产。

 

示例代码:

public class Main {

	// 存放产品对象的队列
	static ArrayList<Computer> coms = new ArrayList<Computer>();

	public static void main(String[] args) {

		// 生产者
		Produce p = new Produce();
		p.start();

		// 消费者
		Customer c = new Customer();
		c.start();
	}
}


public class Computer {

	String name;

	public Computer(String name) {
		this.name = name;
	}

	@Override
	public String toString() {//打印对象时调用
		return name;
	}

}

public class Produce extends Thread {

	int i = 0;

	public void run() {
		while (true) {
			try {
				synchronized (Main.coms) {
					if (Main.coms.size() > 0) {
						Main.coms.wait();
					} else {
						Computer com = new Computer("第" + i + "台电脑");
						Main.coms.add(com);
						System.out.println("生产了电脑:" + com);
						i++;
						Main.coms.notify();
					}
				}
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}

	}

}

public class Customer extends Thread {

	public void run() {
		while (true) {
			try {
				synchronized (Main.coms) {
					// 如果产品不够,就等待
					if (Main.coms.size() <= 0) {
						Main.coms.wait();
					} else {
						Computer c = Main.coms.remove(0);
						System.out.println("-->消费了一台:" + c);
						Main.coms.notify();
					}
				}
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

 

 

 

 

 

 

 

 

线程总结

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

推荐文章
编辑推荐
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号