码迷，mamicode.com
首页 > 编程语言 > 详细

java学习之多线程

时间：2015-03-21 14:05:13      阅读：151      评论：0      收藏：0      [点我收藏+]

标签：多线程   thread   runnable   

进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。

线程(Lightweight Process，LWP)是程序中一个单一的顺序控制流程，有时被称为轻量级进程，是程序执行流的最小单元。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

每一个单进程==多个线程的组合

javav中线程实现的两种方式：

1.继承Thread类

首先覆盖Thread中的run方法

public class MyThread extends Thread {
	private String name; // 定义name属性

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

	public void run() {// 覆写run()方法
		for (int i = 0; i < 50; i++) {// 表示循环10次
			System.out.println("Thread运行：" + name + "，i = " + i);
		}
	}
}

因为线程的启动需要借助底层函数，因此无法通过实例化MyThread后调用run方法直接完成，而必须通过可以启动底层函数的start()方法来启动线程。 

public class ThreadDemo02 {
	public static void main(String[] args) {
		MyThread mt1 = new MyThread("线程A");
		MyThread mt2 = new MyThread("线程B");
		mt1.start(); // 调用线程体
		mt2.start(); // 调用线程体

	}

}

start()方法在jdk1.5中的源码

2.实现Runnable接口

public class MyThread implements Runnable { // 实现Runnable接口
	private String name; // 定义name属性

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

	public void run() {// 覆写run()方法
		for (int i = 0; i < 50; i++) {// 表示循环10次
			System.out.println("Thread运行：" + name + "，i = " + i);
		}
	}
}

public class RunnableDemo01 {
	public static void main(String[] args) {
		MyThread mt1 = new MyThread("线程A");
		MyThread mt2 = new MyThread("线程B");
		new Thread(mt1).start(); // 调用线程体
		new Thread(mt2).start(); // 调用线程体
	}
}
通常开发中多用到第二种方法，因为相比于法一，既可以避免单继承局限，又可以实现现资源共享。
法一实现代码： 

public class MyThread extends Thread {// 继承Thread类
	private int ticket = 5; // 一共才5张票

	public void run() {// 覆写run()方法
		for (int i = 0; i < 50; i++) {// 表示循环10次
			if (this.ticket > 0) {
				System.out.println("卖票：ticket = " + this.ticket--);
			}
		}
	}
}

public class ThreadTicket {
	public static void main(String[] args) {
		MyThread mt1 = new MyThread(); // 一个线程
		MyThread mt2 = new MyThread(); // 一个线程
		MyThread mt3 = new MyThread(); // 一个线程
		mt1.start() ;	// 开始卖票
		mt2.start() ;	// 开始卖票
		mt3.start() ;	// 开始卖票
	}

}

法二实现代码 

public class MyThread implements Runnable {// 实现Runnable接口
	private int ticket = 5; // 一共才5张票

	public void run() {// 覆写run()方法
		for (int i = 0; i < 50; i++) {// 表示循环10次
			if (this.ticket > 0) {
				System.out.println("卖票：ticket = " + this.ticket--);
			}
		}
	}
}
public class RunnableTicket {
	public static void main(String[] args) {
		MyThread mt = new MyThread(); // 一个线程
		new Thread(mt).start() ;	// 开始卖票
		new Thread(mt).start() ;	// 开始卖票
		new Thread(mt).start() ;	// 开始卖票
	}

}

很明显法二只有一个线程，共同售卖5张票而法一三个独立的线程各卖出了5张票。

线程的操作：

设置和取得名字

public class MyThread implements Runnable {

	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + "线程正在运行。");
		}
	}

}
设置线程名字分别为A、B、C
public class ThreadNameDemo01 {
	public static void main(String[] args) {
		MyThread mt = new MyThread(); // Runnable子类实例
		Thread thread1 = new Thread(mt, "线程A");
		Thread thread2 = new Thread(mt, "线程B");
		Thread thread3 = new Thread(mt, "线程C");
		thread1.start() ;
		thread2.start() ;
		thread3.start() ;
	}

}

在java中，至少会同时执行两个进程，分别为Main线程和GC（java垃圾回收）

public class ThreadNameDemo02 {
	public static void main(String[] args) {
		MyThread mt = new MyThread(); // Runnable子类实例
		new Thread(mt, "自定义线程").start();
		mt.run() ;	// 直接通过对象调用
	}
}

线程的休眠 

	public void run() {
		for (int i = 0; i < 10; i++) {
			try {
				Thread.sleep(500); // 每个休眠500毫秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "线程正在运行。");
		}
	}

}


public class ThreadSleepDemo {
	public static void main(String args[]){
		MyThread mt = new MyThread() ;
		new Thread(mt,"线程A").start() ;
		new Thread(mt,"线程B").start() ;
	}
}

线程的中断 

class MyThread implements Runnable {
	public void run() {
		System.out.println("1、进入run()方法体");
		try {
			System.out.println("2、线程休眠20秒钟");
			Thread.sleep(20000); // 每个休眠20秒
			System.out.println("3、线程正常休眠20秒钟");
		} catch (InterruptedException e) {
			System.out.println("4、线程休眠被中断");
			return;// 返回方法调用处
		}
		System.out.println("5、正常结束run()方法体");
	}

}

public class InterruptDemo {
	public static void main(String[] args) {
		MyThread mt = new MyThread();
		Thread thread = new Thread(mt, "线程A");
		thread.start();// 启动线程
		try {
			Thread.sleep(2000); // 保证程序至少执行2秒
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		thread.interrupt(); // 中断
	}

}

设置线程优先级 

class MyThread implements Runnable {
	public void run() {
		for (int i = 0; i < 10; i++) {
			try {
				Thread.sleep(600) ;	// 延迟操作
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "线程正在运行。");
		}
	}
}

public class PriorityDemo01 {
	public static void main(String[] args) {
		MyThread mt = new MyThread();
		Thread t1 = new Thread(mt, "线程A");
		Thread t2 = new Thread(mt, "线程B");
		Thread t3 = new Thread(mt, "线程C");
		t1.setPriority(Thread.NORM_PRIORITY); // 将第一个线程设置为中等优先级
		t3.setPriority(Thread.MAX_PRIORITY); // 将第三个线程设置为最高优先级
		t2.setPriority(Thread.MIN_PRIORITY); // 将第二个线程设置为最低优先级
		t1.start();
		t2.start();
		t3.start();
	}
}

主方法优先级属于普通优先级。

线程的同步

首先看一个异常售票实例

class MyTicketThread implements Runnable {// 实现Runnable接口
	private int ticket = 5; // 一共才5张票

	public void run() {// 覆写run()方法
		for (int i = 0; i < 50; i++) {// 表示循环10次
			if (this.ticket > 0) {
				try {
					Thread.sleep(300);// 延迟
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("卖票：ticket = " + this.ticket--);
			}
		}
	}
}
public class SynDemo01 {

	public static void main(String[] args) {
		MyTicketThread mt = new MyTicketThread(); // 一个线程
		new Thread(mt, "票贩子-A ").start(); // 开始卖票
		new Thread(mt, "票贩子-B ").start(); // 开始卖票
		new Thread(mt, "票贩子-C ").start(); // 开始卖票
	}
}

因为延迟，可能导致售票发生数值异常。

解决办法一：利用synchronized方法设置同步代码使售票程序同步起来，同一时间段只允许一个线程访问、

class MyTicketThread implements Runnable {// 实现Runnable接口
	private int ticket = 5; // 一共才5张票

	public void run() {// 覆写run()方法
		for (int i = 0; i < 50; i++) {// 表示循环10次
			synchronized (this) {// 形成同步代码块
				if (this.ticket > 0) {
					try {
						Thread.sleep(300);// 延迟
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("卖票：ticket = " + this.ticket--);
				}
			}
		}
	}
}

public class SynDemo02 {
	public static void main(String[] args) {
		MyTicketThread mt = new MyTicketThread(); // 一个线程
		new Thread(mt, "票贩子-A ").start(); // 开始卖票
		new Thread(mt, "票贩子-B ").start(); // 开始卖票
		new Thread(mt, "票贩子-C ").start(); // 开始卖票
	}
}

解决方法二：设定同步方法 

class MyTicketThread implements Runnable {// 实现Runnable接口
	private int ticket = 5; // 一共才5张票

	public void run() {// 覆写run()方法
		for (int i = 0; i < 50; i++) {// 表示循环10次
			this.sale(); // 调用同步方法
		}
	}
	public synchronized void sale() {// 增加同步方法
		if (this.ticket > 0) {
			try {
				Thread.sleep(300);// 延迟
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("卖票：ticket = " + this.ticket--);
		}
	}
}

public class SynDemo03 {
	public static void main(String[] args) {
		MyTicketThread mt = new MyTicketThread(); // 一个线程
		new Thread(mt, "票贩子-A ").start(); // 开始卖票
		new Thread(mt, "票贩子-B ").start(); // 开始卖票
		new Thread(mt, "票贩子-C ").start(); // 开始卖票
	}
}

线程的死锁

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

class FanBo {
	public synchronized void say(ZhangYang zy) {
		System.out.println("把钱给我，放了你弟弟。");
		zy.give();
	}

	public synchronized void give() {
		System.out.println("得到了钱，同时被警察抓了。");
	}
}

class ZhangYang {
	public synchronized void say(FanBo fb) {
		System.out.println("把弟弟放了，我给你钱。");
		fb.give();
	}

	public synchronized void give() {
		System.out.println("弟弟救回来，同时报案了。");
	}
}

public class DeadLockDemo implements Runnable {
	private FanBo fb = new FanBo();
	private ZhangYang zy = new ZhangYang();

	public DeadLockDemo() {
		new Thread(this).start() ;
		zy.say(fb);
	}

	public void run() {
		fb.say(zy);
	}

	public static void main(String[] args) {
		new DeadLockDemo();
	}

}

多个进程共享统一资源的时候需要同步，而过多的同步又会产生死锁。


java学习之多线程

标签：多线程   thread   runnable   

原文地址：http://blog.csdn.net/u014492609/article/details/44493039
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！