多线程
1、线程、进程
进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行；
一个进程中至少有一个线程。
2、创建多线程方式
方式一:继承Thread类。
步骤：1，定义类继承Thread。
2，复写Thread类中的run方法。
3，调用线程的start方法，
方式二：实现Runnable接口
步骤：1.建立Runable对象
2.使用参数为Runnable对象的构造方法创建Thread；
3.调用startfang方法启动线程。
3.Thread与Runnable实现方式的区别：
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable，线程代码存在接口的子类的run方法。
Runnable好处：避免了单继承的局限
4、线程同步机制
同步机制中如何找到问题：
明确哪些代码是多线程运行代码；
确定共享数据；
确定多线程运行代码中哪些是操作共享数据；
5、同步方法中使用的锁的不同：
6、死锁
死锁出现情况：同步嵌套
/*
需求：编写一个死锁程序
思路：死锁常出现在嵌套同步块的程序中
*/
package unit18;
class ObjectLock{
static ObjectLock objA = new ObjectLock();
static ObjectLock objB = new ObjectLock();
}
class DeadTest implements Runnable{
private Boolean flag;
DeadTest(Boolean flag){
this.flag = flag;
}
public void run(){
if(flag){
while(true){
synchronized(ObjectLock.objA){//获得锁A,请求锁B
System.out.println(Thread.currentThread().getName()+".....lock objA");
synchronized(ObjectLock.objB){
System.out.println(Thread.currentThread().getName()+".....lock objB");
}
}
}
}else{
while(true){
synchronized(ObjectLock.objB){//获得锁B，请求锁A
System.out.println(Thread.currentThread().getName()+".....lock objB");
synchronized(ObjectLock.objA){
System.out.println(Thread.currentThread().getName()+".....lock objA");
}
}
}
}
}
}
public class DeadLockTest {
public static void main(String args[]){
Thread t1 = new Thread(new DeadTest(true));
Thread t2 = new Thread(new DeadTest(false));
t1.start();
t2.start();
}
}
7.线程间通信
线程间通讯：
其实就是多个线程在操作同一个资源，但是操作的动作不同。
/*
线程间通信
需求：输入线程为资源对象信息赋值，输出线程输出对象细信息
*/
package unit18;
//定义资源对象Person
class Person{
public String name;
public String sex;
public Boolean flag= false;//flag为false表示对象信息值为空
// Person(String name,String sex){
// this.name = name;
// this.sex = sex;
// }
}
//定义输入类Input
class Input implements Runnable{
private Person per;
Input(Person per){
this.per = per;
}
public void run(){
int x = 0;
while(true){
synchronized(per){
if(per.flag)//如果标记为真，暂停输入线程，等待输出线程输出对象信息
try {per.wait();} catch (InterruptedException e) {}
//如果标记为假，输入线程输入信息
if(x==0){
per.name = "mike";
per.sex = "man";
}else{
per.name = "王丽";
per.sex = "女";
}
x = (x+1)%2;
per.flag = true;
per.notify();
}
}
}
}
//定义输出类Output
class Output implements Runnable{
private Person per;
Output(Person per){
this.per = per;
}
public void run(){
while(true){
synchronized(per){
if(!per.flag)
try { per.wait();} catch (InterruptedException e) {}
System.out.println(per.name + "......"+ per.sex);
per.flag = false;
per.notify();
}
}
}
}
public class InputOutputTest {
public static void main(String args[]){
Person per = new Person ();
Thread t1 = new Thread(new Input(per));
Thread t2 = new Thread(new Output(per));
// Thread t3 = new Thread(new Input(per));
// Thread t4 = new Thread(new Output(per));
t1.start();
t2.start();
// t3.start();
// t4.start();
}
总结：学习多线程后，编程思想和以前截然不同；现实中很多事物都具有多线程性质，所以我们因该积极转换编程思维，已进入多线程编程的思维方式。
原文：http://www.cnblogs.com/chizhongyue/p/4606049.html