进程和线程的概念
- 进程是一个动态的概念
a. 进程是程序的一次动态执行的过程，占用特定的地址空间。
b. 每个进程都是独立的，由三部分组cpu data code。
c. 缺点是浪费内存,cpu的负担。 - 线程是进程中的一个单一的连续控制流程/执行路径
a. 线程又被称为一个轻量级的进程。
b. 一个进程可以拥有多个并行的线程。
c. 一个进程中的线程共享相同的内存单元/内存地址空间，可以访问相同的变量和对象，而且他们从 同一堆中分配对象-通信、数据交换、同步操作。（容易造成并发）
d. 由于线程间的同信是在同一个地址空间进行的，所以不需要额外的通信机制，这就使得通信更 而且信息传递的速度也更快。
怎么模拟实现的多线程
cup调度的过程中有一个极短的时间片可以来回切换线程。
多线程的实现方式
- 继承Thread类重写run()/线程体方法
缺点：Java只支持单进程如果我们的类继承了一个类那就无法再继承Thread类。
package com.company;
//继承THread类
public class thread extends Thread {
public void run(){
for(int i = 0; i < 100; i++){
System.out.println("兔子"+i);
}
}
}
class thread1 extends Thread {
public void run(){
for(int i = 0; i < 100; i++){
System.out.println("乌龟"+i);
}
}
}
package com.company;
//实现Thread调用stare方法才能实现线程的调度。
public class threadImplement {
public static void main(String[] args){
thread th = new thread();
thread1 th1 = new thread1();
th.start();
th1.start();
}
}
- 通过Runnable接口实现多线程
使用了静态代理模式，推荐使用runnable。
优点：避免单继承，方便共享资源，同一份资源多个代理访问。
package com.company;
/*
* 使用Runnable创建线程（Thread类实现了Runnable接口）
* 1. 类实现runnable接口+重写run（）-->真是角色
* 2. 启动多线程 使用静态代理
* */
public class runnable implements Runnable{
@Override
public void run() {
for (int i = 0 ;i < 100; i++){
System.out.println("天天"+ i);
}
}
}
package com.company;
public class runnabelImplement {
public static void main(String[] args) {
runnable ab = new runnable(); //创建真实角色类
Thread th = new Thread(ab); //创建代理角色并引用真实角色
th.start();
for (int i = 0 ;i < 100; i++){
System.out.println("hahah"+ i);
}
}
}
- 实现Callable接口实现多线程
优点：可以获取返回值，可以抛出异常
缺点： 繁琐
思路：
1). 创建Callable实现类+重写call
2). 借助执行调度服务ExecutorService,获取Future对象
3). 获取值result.get()
4)停止服务ser.shutdownNow();
package com.company;
import java.util.concurrent.*;
/*
* 使用callable实现多线程
* */
public class Call {
public static void main(String[] args) throws ExecutionException, InterruptedException { //创建一个线程
ExecutorService ser = Executors.newFixedThreadPool(1);
Race ra = new Race();
//获取值
Future<Integer> result = ser.submit(ra);
int num = result.get();
System.out.println(num);
//停止服务
ser.shutdownNow();
}
}
class Race implements Callable<Integer> {
@Override
public Integer call() throws Exception {
return 1000;
}
}
线程的状态
- 初始(NEW)：
新创建了一个线程对象，但还没有调用start()方法。
实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。 - 可运行(RUNNABLE)：
Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“可运行”。
线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。调用线程的start()方法，此线程进入就绪状态。当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。锁池里的线程拿到对象锁后，进入就绪状态。 - 阻塞(BLOCKED)：
当一个线程试图获取一个内部的对象锁，而该锁被其它线程持有，则该锁进入阻塞状态。 - 等待(WAITING)：
当线程等待另一个线程通知调度器一个条件的时候，它自己进入等待状态。 - 计时等待(TIMED_WAITING)：
该状态不同于WAITING，它可以在指定的时间后自行返回。如：join wait sleep 等 - 终止(TERMINATED)：
表示该线程已经执行完毕。一个是因为run方法正常退出而自然死亡，一个是因为没有捕获异常终止了run方法而意外死亡。
线程进入等待的方法
-
sleep()
sleep()方法需要指定等待的时间，它可以让当前正在执行的线程在指定的时间内暂停执行，进入等待状态，该方法既可以让其他同优先级或者高优先级的线程得到执行的机会，也可以让低优先级的线程得到执行机会。但是sleep()方法不会释放“锁标志”，也就是说如果有synchronized同步块，其他线程仍然不能访问共享数据。 -
wait()
wait()方法需要和notify()及notifyAll()两个方法一起介绍，这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用，也就是说，调用wait()，notify()和notifyAll()的任务在调用这些方法前必须拥有对象的锁。注意，它们都是Object类的方法，而不是Thread类的方法。
wait()方法与sleep()方法的不同之处在于，wait()方法会释放对象的“锁标志”。当调用某一对象的wait()方法后，会使当前线程暂停执行，并将当前线程放入对象等待池中，直到调用了notify()方法后，将从对象等待池中移出任意一个线程并放入锁标志等待池中，只有锁标志等待池中的线程可以获取锁标志，它们随时准备争夺锁的拥有权。当调用了某个对象的notifyAll()方法，会将对象等待池中的所有线程都移动到该对象的锁标志等待池。
除了使用notify()和notifyAll()方法，还可以使用带毫秒参数的wait(long timeout)方法，效果是在延迟timeout毫秒后，被暂停的线程将被恢复到锁标志等待池。
此外，wait()，notify()及notifyAll()只能在synchronized语句中使用，但是如果使用的是ReenTrantLock实现同步，该如何达到这三个方法的效果呢？解决方法是使用ReenTrantLock.newCondition()获取一个Condition类对象，然后Condition的await()，signal()以及signalAll()分别对应上面的三个方法。 -
yield()
yield()方法和sleep()方法类似，也不会释放“锁标志”，区别在于，它没有参数，即yield()方法只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行，另外yield()方法只能使同优先级或者高优先级的线程得到执行机会，这也和sleep()方法不同。
package com.company;
public class yield extends Thread{
public static void main(String[] args) throws InterruptedException {
yield jo = new yield();
jo.start();
for (int i = 100 ; i>1 ; i--){
if(i%20==0){
Thread.yield(); //暂停本线程(main)
}
System.out.println("join"+i);
}
}
public void run(){
for (int i = 100 ; i>1 ; i--){
System.out.println("main"+i);
}
}
}
- join()
thread.Join()把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。
package com.company;
public class join extends Thread {
public static void main(String[] args) throws InterruptedException {
join jo = new join();
Thread t = new Thread(jo);
t.start();
for (int i = 100 ; i>1 ; i--){
if(i==20){
t.join();
}
System.out.println("join"+i);
}
}
public void run(){
for (int i = 100 ; i>1 ; i--){
System.out.println("main"+i);
}
}
}
