JAVA基础多线程

---

一、线程与进程   

    进程：正在计算机中运行的一个程序，当一个程序进入内存运行，即变成一个进程。一个软件至少有一个进程，
有的软件在点击一个应用图标是可能会给你开多个进程，如：360全家桶。
    线程：软件在计算机中执行的一条路径。软件可以是多线程的。
    总结：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。而多线程就是一个程序中有多个线程
在同时执行。而JAVA为我们提供了2种方式实现多线程：1、继承Thread类 2、实现Runnable接口。我们在编写程
序时的主方法就是一个单独的线程，线程名叫 "main"。而JAVA虚拟机Jvm运行是多线程运行。

二、Thread类

    JAVA实现多线程其中的一种方法就是继承Thread类，Thread是程序中的执行线程。Java 虚拟机允许应用程序并
发地运行多个执行线程。Thread类常用的构造方法有：1、分配新的 Thread 对象 - Thread()，2、分配新的Thread
对象，将指定的name作为线程名称 - Thread(String name)。其常用的方法有：
1、改变线程名称，使之与参数 name 相同：setName(String name)
2、该线程要执行的操作：run()
3、在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）：sleep()
4、使该线程开始执行；Java 虚拟机调用该线程的 run 方法：start()
5、返回该线程的名称：getName()
6、静态方法，返回值为Thread对象 - 返回对当前正在执行的线程对象的引用：currentThread()
    A:创建线程的步骤：
1.定义一个类继承Thread。
2.重写run方法。
3.创建子类对象(创建线程对象)。
4.调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。
  举例：

//定义类MyThread继承Thread类
public class MyThread extends Thread {
@Override
// 重写Thread类里的run方法
public void run() {
// 想要多线程执行的代码
for (int i = 0; i < 100; i++) {
// 获取线程名称和循环的次数
System.out.println(getName() + " " + i);
}
}
}

主函数：

public static void main(String[] args) {
// 创建线程一
MyThread myThread01 = new MyThread();
// 为线程一设置线程名
myThread01.setName("线程一");
// 开启线程一
myThread01.start();
// 创建线程二
MyThread myThread02 = new MyThread();
// 为线程二设置线程名
myThread02.setName("线程二");
// 开启线程二
myThread02.start();
}

三、Runnable接口

    JAVA实现多线程的另一种方法就是实现Runnable接口，实现 run 方法。然后创建Runnable的子类对象，
传入到某个线程的构造方法中，开启线程。Runnable接口其实就是用来指定每个线程要执行的任务，在由线
程类Thread来执行这些任务。Runnable接口只有一个要实现的方法：run(),作用与Thread类的run方法类似，
在启动该线程时将被调用，也就是说将由其实现类来实现run方法。Runnable接口的常用实现类是Thread类。
    B:创建线程的步骤:
1、定义类实现Runnable接口。
2、覆盖接口中的run方法。
3、创建Thread类的对象
4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
5、调用Thread类的start方法开启线程。
  举例：

//创建MyRunable类实现Runnable接口
public class MyRunable implements Runnable {
@Override
//重写run方法
public void run() {
/*循环
Thread.currentThread().getName：
通过Thread类的静态方法currentThread()方法，返回正在执行的线程对象，并获取线程名*/
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + " :" + i);
}
}
}

  *主方法：

public static void main(String[] args) {
// 获取MyRunable对象（线程任务）
MyRunable r = new MyRunable();
// 根据线程任务创建线程一
Thread t1 = new Thread(r);
// 命名
t1.setName("线程一");
// 开启线程
t1.start();
// 根据线程任务创建线程二
Thread t2 = new Thread(r);
t2.setName("线程二");
t2.start();
}

四、多线程安全

    由于CUP对线程的处理具有随机性,这就导致了当线程1进入某一循环，还没有执行循环里的语句时，
CUP突然切换到线程2，线程2也进入了循环语句。这样就会导致本应该只执行一次的条件执行了2次，导致
线程不安全的问题出现。
    问题出现的原因：
* 要有多个线程
* 要有被多个线程所共享的数据
* 多个线程并发的访问共享的数据。
  用实现Runnable接口的方式对同一数据进行

操作可能就会出现这种重复的问题：

(一)、多线程安全的解决

    问题出现了该如何解决呢？多线程处理的机制其实和我们在火车上厕所类似。在火车上有好多人都要去厕所，
但是厕所只能供一个人使用，2个人如果一起挤进了厕所就会发生一些“事情”，那么火车是怎么解决这个问题的呢？
我们可以在厕所的门上上一把锁，路人甲进厕所后把门锁起来，方便完之后再把锁打开，路人乙在进去把门锁上。
而JAVA为了解决多线程的并发安全问题，也给我们提供了这么一把“锁” - 同步代码块和同步方法。

1、同步代码块：

synchronized(锁对象){

}
  举例：

public class MyRunable implements Runnable {
// 设置一个被操作的数据
int i = 100;

@Override
public void run() {
while (true) {
// 设置同步代码块
synchronized (MyRunable.class) {
try {
// 为了不要太快，先睡一会
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 对数据进行操作
if (i > 0) {
System.out.println(Thread.currentThread().getName() + " " + i--);
}
}
}
}
}

*入口方法：

public static void main(String[] args) {
MyRunable runable = new MyRunable();
Thread t1 = new Thread(runable);
t1.setName("线程A");
Thread t2 = new Thread(runable);
t2.setName("线程B");
Thread t3 = new Thread(runable);
t3.setName("线程C");
t1.start();
t2.start();
t3.start();
}

    锁对象：可以是java中的任意对象。多个同步代码块必须使用同一个对象，才能实现多个代码块之间的同步。一
般使用当前类的.class对象

2、同步方法：

非静态方法：this
静态方法：字节码对象（类名.class）
  举例：

public class MyRunable implements Runnable {
// 设置一个被操作的数据
int i = 100;

public void run() {
while (true) {
method();
}
}

private synchronized void method() {

try {
Thread.sleep(150);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (i > 0) {
System.out.println(Thread.currentThread().getName() + " :" + i);
i--;
}else {
System.exit(0);
}
}

  *入口方法：

public static void main(String[] args) {
MyRunable runable = new MyRunable();
Thread t1 = new Thread(runable);
t1.setName("线程A");
Thread t2 = new Thread(runable);
t2.setName("线程B");
Thread t3 = new Thread(runable);
t3.setName("线程C");
t1.start();
t2.start();
t3.start();
}

3、优缺点

* 同步：安全性高，效率低。
* 非同步：效率高，但是安全性低。

五、使用多线程对同一数据进行不同的操作

  代码：

public class Demo {
    public static class AddSub {
        //提供原子操作的Integer的类（无锁的线程安全整数 AtomicInteger）
        AtomicInteger at = new AtomicInteger(1);
        int j = 1;

        public static void main(String[] args) {
            AddSub ab = new AddSub();
            Add a = ab.new Add();
            Sub b = ab.new Sub();
            Thread t1 = new Thread(a);
            Thread t2 = new Thread(a);
            Thread t3 = new Thread(b);
            Thread t4 = new Thread(b);
            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }

        public synchronized void add() {
            j++;
            System.out.println("add:" + j);
        }

        public synchronized void sub() {
            j--;
            System.out.println("sub:" + j);
        }

        class Add implements Runnable {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    add();
                }

            }
        }

        class Sub implements Runnable {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    sub();
                }

            }
        }
    }
}