Java进程，线程，多线程。重写run()方法，通过.start()方法启动子线程，synchronized:同步（锁），sleep()、wait()、join()、yield()的区别

---

前言

• 进程：当前正在运行的程序，一个应用程序在内存中的执行区域
• 线程：进程中的一个执行控制单元，执行路径
• 一个进程可以有一个线程，也可以有多个线程
• 单线程：安全性高，但是效率低
• 多线程：安全性低，效率高

---

一、多线程的实现方式：

方式1：一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例
方式2：创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动

•  String getName()      返回该线程的名称。 
  

•  void   setName(String name) 改变线程名称，使之与参数 name 相同。
  

二、类声明为 Thread 的子类

1.将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。

代码如下（示例）：

public class MyThread extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(getName()+i);
		}
	}
}

2.创建第二个类，接下来可以分配并启动该子类的实例

代码如下（示例）：

public class ThreadDemo2 {
	public static void main(String[] args) {
		//创建线程实例
		MyThread t = new MyThread();
		t.setName("第一个线程：");
		//启动线程
		t.start();
		MyThread t2 = new MyThread();
		t2.setName("第二个线程");
		//启动线程
		t2.start();
	}
}

3.结果，两个随机输出到99。

---

三、实现 Runnable 接口的类

1.声明实现 Runnable 接口的类。该类然后重写 run 方法。

代码如下（示例）：

public class MyThread2 implements Runnable {
	int num;
	public MyThread2(int num) {
		this.num = num;
	}
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			//Thread t = Thread.currentThread();
			//System.out.println(t.getName() + ":" + i);	
			//链式编程
			System.out.println(Thread.currentThread().getName() + ":" + i + "    参数："+num++);
		}
	}
}

2.创建第二个类，然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动

Thread(Runnable target)
static Thread currentThread() :返回当前线程对象
代码如下（示例）：

public static void main(String[] args) {
		method2();
	}
	private static void method() {
		//创建线程实例
		MyThread2 mt = new MyThread2(1);
		Thread t = new Thread(mt);
		t.setName("李四");
		//启动线程
		t.start();
		//两个实例都是单独的，两个num都是分别加到100
		//两个实例都是单独的，两个num都是分别加到100
		//创建线程实例
		MyThread2 mt2 = new MyThread2(1);
		Thread t2 = new Thread(mt2);
		t2.setName("老王");
		//启动线程
		t2.start();
	}
	

	private static void method2() {
		MyThread2 mt = new MyThread2(1);
		//创建线程实例
		Thread t = new Thread(mt);
		t.setName("李四");
		//启动线程
		t.start();
		//两个线程都是一个实例，num加到200；即李四：99，老王：99，但是nun=200了
		//两个线程都是一个实例，num加到200；即李四：99，老王：99，但是nun=200了
		//创建线程实例
		Thread t2 = new Thread(mt);
		t2.setName("老王");
		//启动线程
		t2.start();
	}

3.结果

第一个双方都是输数名字：99，参数：99。

第二个双方都是输出名字：99，但参数因为是同一个空间所以参数最后达到了200；

---

四、synchronized:同步（锁）（卖车票问题）

1.数据安全问题出现的原因：

•  要有多个线程
  

•  要有被多个线程所共享的数据
  

•  多个线程并发的访问共享的数据
  

2.synchronized:同步（锁）

可以修饰代码块和方法，被修饰的代码块和方法一旦被某个线程访问，则直接锁住，其他的线程将无法访问

• 同步代码块：
  synchronized(锁对象){
  }
• 注意：锁对象需要被所有的线程所共享

3.主类，调用创建子进程的类。

代码如下（示例）：

public class TicktetTest {
	public static void main(String[] args) {
		//创建线程对象
		TicketThread tt = new TicketThread();
		
		Thread t = new Thread(tt);
		t.setName("窗口1");
		Thread t2 = new Thread(tt);
		t2.setName("窗口2");
		Thread t3 = new Thread(tt);
		t3.setName("窗口3");
		//启动线程对象
		t.start();
		t2.start();
		t3.start();
	}
}

4.同步代码块方法

代码如下（示例）：

public class TicketThread implements Runnable {
	int tickets = 100;//火车票数量
	Object obj = new Object();
	
	@Override
	public void run() {
		//出售火车票
		while(true) {
			synchronized (obj) {
				if(tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + ":" +tickets--);
				}
			}
		}
	}
}

不存在超卖结果。

5.同步方法

注意：
*非静态同步方法的锁对象是this
*静态的同步方法的锁对象是当前类的字节码对象
代码如下（示例）：

public class TicketThread implements Runnable {
	static int tickets = 100;// 火车票数量
	Object obj = new Object();

	@Override
	public void run() {
		// 出售火车票
		while (true) {
			method2();
		}
	}
	//非静态同步方法
	private synchronized void method() {
		if (tickets > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ":" + tickets--);
		}
	}
	//静态的同步方法
	private static synchronized void method2() {
		if (tickets > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ":" + tickets--);
		}
	}
}

sleep()、wait()、join()、yield()的区别
1.锁池
所有需要竞争同步锁的线程都会放在锁池当中，比如当前对象的锁已经被其中一个线程得到，则其他线程需要在这个锁池进行等待，当前面的线程释放同步锁后锁池中的线程去竞争同步锁，当某个线程得到后会进入就绪队列进行等待cpu资源分配。
2.等待池
当我们调用wait（）方法后，线程会放到等待池当中，等待池的线程是不会去竞争同步锁。只有调用了notify（）或notifyAll()后等待池的线程才会开始去竞争锁，notify（）是随机从等待池选出一个线程放到锁池，而notifyAll()是将等待池的所有线程放到锁池当中
1、sleep 是 Thread 类的静态本地方法，wait 则是 Object 类的本地方法。
2、sleep方法不会释放lock，但是wait会释放，而且会加入到等待队列中。
3、sleep方法不依赖于同步器synchronized，但是wait需要依赖synchronized关键字。
4、sleep不需要被唤醒（休眠之后推出阻塞），但是wait需要（不指定时间需要被别人中断）。
5、sleep 一般用于当前线程休眠，或者轮循暂停操作，wait 则多用于多线程之间的通信。
6、sleep 会让出 CPU 执行时间且强制上下文切换，而 wait 则不一定，wait 后可能还是有机会重新竞争到锁继续执行的。
7、yield（）执行后线程直接进入就绪状态，马上释放了cpu的执行权，但是依然保留了cpu的执行资格，所以有可能cpu下次进行线程调度还会让这个线程获取到执行权继续执行
8、join（）执行后线程进入阻塞状态，例如在线程B中调用线程A的join（），那线程B会进入到阻塞队列，直到线程A结束或中断线程。

---

总结

都是要重写run()方法，而且不是直接调用run()方法，直接调用就是相当于普通的方法。而不是启动子线程。
启动子线程是通过.start()方法启动的。
多线程是对数据不安全的，需要通过同步锁解决。
线程的执行时随机的，因为CPU执行程序的随机性。
sleep方法不会释放lock，但是wait会释放，而且会加入到等待队列中。因此sleep 会让出 CPU 执行时间且强制上下文切换，而 wait 则不一定，wait 后可能还是有机会重新竞争到锁继续执行的。