java线程

1、进程：每个进程执行，都有一个执行的顺序，该顺序是一个执行路径或者叫一个控制单元。

2、线程：进程中的一个独立的控制单元

              一个进程中至少有一个线程。

3、java VM启动的时候，会有一个进程java.exe，至少包含一个线程，在main方法中称之为主线程。

4、自定义线程：两种创建方法

       1、Thread类 Thread t  = new Thread(); t.start();

            继承Thread，重写run（）调用start（），某一时刻只有一个线程在进行（多核除外）

            Thread中的run方法用于存储线程要运行的代码。

class Demo extends Thread {
	public void run() {
		for (int i = 0; i <= 50; i++) {
			System.out.println("demo run---" + i);
		}
	}
}

public class ThreadDemo {

	public static void main(String[] args) {
		Demo d = new Demo();//创建一个线程
		d.start();
		for (int i = 0; i <= 50; i++) {
			System.out.println("main run----" + i);
		}
	}

}

结果：

main run----0
demo run---0
main run----1
demo run---1
main run----2
demo run---2
main run----3
demo run---3
demo run---4
demo run---5
main run----4
main run----5
main run----6
main run----7
main run----8
main run----9
main run----10
demo run---6
demo run---7
demo run---8
demo run---9
demo run---10
demo run---11
demo run---12
demo run---13
main run----11
demo run---14
main run----12
demo run---15
main run----13
demo run---16

        2、实现Runnable接口的类，重写实现run()方法。

购票Demo：

class Tick implements Runnable {
	private int tick = 100;

	@Override
	public void run() {
		while (true) {
			if (tick >= 0) {
				System.out.println(Thread.currentThread() + "sales---" + tick--);
			}
		}
	}

}
public class ThreadDemo2 {

	public static void main(String[] args) {
		Tick t = new Tick();
		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();
	}
}

实现方式和继承方式，两种方法比较：

实现方式：避免了单继承的局限性

在定义线程的时候，建议使用实现方式。

继承Thread：线程代码放在Thread的子类run方法中。

实现Runable：线程代码放在接口的子类的run方法中。

5、线程的运行状态：

6、多线程的安全问题：

当多条语句在操作同一个线程共享数据的时候，一个线程多多条语句只执行了一部分，另一个线程就参与进来，导致共享数据错误。

解决方法：

对多条共享数据的语句，只能让一个线程执行完，再执行其他的线程，期间不允许其他线程运行。

同步代码块 

synchronized(对象){

     需要同步的代码块   

}

只有持有锁的线程可以在同步代码块中执行。

使用同步的前提：

1、两个及两个以上的线程。

2、多个线程必须使用同一个锁。

同步函数使用的锁是this。

如果同步函数被static修饰，使用的锁是所在类的字节码文件即：类.class

死锁：

package thread;
// 死锁
class MyLock {
	public static MyLock myLocka = new MyLock();
	public static MyLock myLockb = new MyLock();
}

class Dead implements Runnable {
	private boolean flag;

	Dead(boolean flag) {
		this.flag = flag;
	}

	public void run() {
		if (flag) {
			synchronized (MyLock.myLocka) {
				System.out.println("if myLocka");
				synchronized (MyLock.myLockb) {
					System.out.println("if myLockb");
				}
			}
		} else {
			synchronized (MyLock.myLockb) {
				System.out.println("else myLockb");
				synchronized (MyLock.myLocka) {
					System.out.println("else myLocka");
				}
			}
		}
	}
}

public class DeadLock {

	public static void main(String[] args) {
		Dead d1 = new Dead(true);
		Dead d2 = new Dead(false);
		Thread t1 = new Thread(d1);
		Thread t2 = new Thread(d2);
		t1.start();
		t2.start();

	}

}

线程间通信：

多个线程操作同一资源，操作的动作不同。