@[TOC](多线程与高并发)
# 认识并发与并行
并发是针对一个CPU来讲，“同一时间”执行多个任务--实质上是划分时间片，由于时间很短给人的感觉是是同时执行的；
并行是针对多个CPU来讲的，同时执行多个任务（一个CPU执行一个），这是真正意义上的同时执行；
## 入门程序分析（打印---HelloWorld）
```java
class Car{
public void drive(){
System.out.println("我会跑");
}
}
public class HuiXinThread {
public static void main(String[] args) {
Car car=null;
System.out.println("HelloWorld");//主线程---main()
car.drive();//异常处理的线程---
new Car().drive();//运行完毕，new Car()匿名对象会被回收--垃圾收集器
}
}
```
所以在我们初学java时，并非只有一个线程，其实是多线程的包括 主线程、处理异常的线程，以及垃圾收集器线程等等；
### 线程之间是如何抢占CPU资源的？
先来看一个案例----
当我们打开一个程序前，其实就是存放在电脑中的代码（静态的），打开之后，这个程序才算开启，（为他分配空间以及CPU资源），然后在这个程序中开启不同的功能--即开启了多个线程，然后CPU再次为这些线程服务，如果线程过多，CPU不够用，那就会使得一个CPU要执行多个线程---形成了并发（采用时间片机制），同时可以为线程设置优先级来提高相应线程被先执行的概率（并不是优先级低就一定会被后执行）
### 自定义线程的执行
线程的创建方式---
第一种---继承Thread类
```java
class Car extends Thread{
@Override
public void run(){
for (int i=0;i<10;i++){
System.out.println("我会跑");}
}
}
public class HuiXinThread {
public static void main(String[] args) {
//主线程---main()
for (int i = 0; i <10 ; i++) {
System.out.println("HelloWorld"+i);
}
new Car().run();
}
}
```
这一种并不是多线程，因为该方式只是把run（）当成一个普通方法来执行的；，所以运行结果是 先执行main--主线程，然后执行run()，此时run也是属于主线程里面的；
```java
class Car extends Thread{
@Override
public void run(){
for (int i=0;i<10;i++){
System.out.println("我会跑");}
}
}
public class HuiXinThread {
public static void main(String[] args) {
//主线程---main()
for (int i = 0; i <10 ; i++) {
System.out.println("HelloWorld"+i);
}
new Car().start();
}
}
```
start()是父类的方法，但是与逆行结果依然跟上面一样---
原因是我们在主线程（for循环）执行时并没有子线程参与进来，要想实现并发效果需要调整一下start(）方法的位置--
```java
class Car extends Thread{
@Override
public void run(){
for (int i=0;i<10;i++){
System.out.println("我会跑"+i);}
}
}
public class HuiXinThread {
public static void main(String[] args) {
//子线程
new Car().start();
//主线程---main()
for (int i = 0; i <10 ; i++) {
System.out.println("HelloWorld"+i);
}
}
}
```
> 运行后发现---有时候并不一定会出现并发---当运行量少的时候；
# 为线程设置名字和获取线程名字
```java
public class Car extends Thread{
@Override
public void run(){
for (int i=0;i<10;i++){
System.out.println(this.getName()+i);}
}
}
public class HuiXinThread {
public static void main(String[] args) {
//子线程
Car car= new Car();
car.setName("小汽车");
car.start();
//主线程---main()
for (int i = 0; i <10 ; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
```
还可以通过构造器来设置线程名字---
```java
public class Car extends Thread{
public Car(String name){
super(name);
}
@Override
public void run(){
for (int i=0;i<10;i++){
System.out.println(this.getName()+i);}
}
}
public class HuiXinThread {
public static void main(String[] args) {
//子线程
Car car= new Car("小火车");
//car.setName("小汽车");
car.start();
//主线程---main()
for (int i = 0; i <10 ; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
```
设置线程名的父类构造方法---
# 线程开启的方式---
## 继承Thread类--
演示代码如上，不在赘述----注意点为 开启线程是start()方法，而run()方法还是当作一个普通方法来处理的；
start()源码---
> 此方法不为主方法线程或“系统”调用。
> 虚拟机创建/设置的组线程。 添加的新功能
> 到这个方法以后可能还需要添加到VM中。
## 实现Runable接口
```java
class BuyBook implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("i---"+Thread.currentThread());
}
}
}
public class Test {
public static void main(String[] args) {
BuyBook bb= new BuyBook();
bb.run();
for (int i = 0; i <10 ; i++) {
System.out.println("i---"+Thread.currentThread());
}
}
}
```
> Runnable接口中只有一个run方法,
并没有发现start方法,需要怎么做呢?
start()方法在Thread类中,所以要先在创建一个Thread的对象
```java
class BuyBook implements Runnable{
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println("i---"+Thread.currentThread());
}
}
}
public class Test {
public static void main(String[] args) {
Thread.currentThread().setName("主线程");
BuyBook bb= new BuyBook();
Thread thread= new Thread(bb);
thread.setName("子线程");
thread.start();
for (int i = 0; i <3 ; i++) {
System.out.println("i---"+Thread.currentThread());
}
}
}
```
> public Thread(Runnable target) {//构造器--传入的是Runnable对象
this(null, target, "Thread-" + nextThreadNum(), 0);
}
当处理量少的时候得到的结果像是顺序执行的,多运行几次就可以了;
