《day14---多线程入门_进阶》

/*
多线程：

进程：正在执行中的程序，一个应用程序启动后在内存中运行的那片空间。进程具有动态性和并发性。

线程：进程中的一个执行单元。负责进程中的程序的运行的。一个进程中至少要有一个线程。
一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

程序启动了多线程，有什么应用呢？
可以实现多部分程序同时执行。专业术语称之为 并发。

多线程的使用可以合理使用cpu的资源，如果线程过多会导致降低性能。

cpu在处理程序时是通过快速切换完成的。在我们看来好像随机一样。
*/

//03-多线程-主线程的运行方式&创建线程的第一种方式。
/*
通过代码来演示之前和之后的区别。

在之前的代码中，jvm启动后，必然有一个执行路径(线程)从main方法开始的，
一直执行到main方法结束。这个线程在java中称之为主线程。

当主线程在这个程序中执行时，如果遇到了循环而导致停留时间过长，
就无法执行下面的程序。
可不可以实现一个主线程负责执行其中一个循环，由另一个线程负责其他代码的执行。
实现多部分的代码同时执行。
这就是多线程技术可以解决的问题。

该如何创建线程呢？

通过API中的英文Thread搜索。查到了Thread类。
通过阅读Thread类中的描述。
创建线程有两种方式。
1，继承Thread类。
1.1 定义一个类去继承Thread.
1.2 重写run方法。
1.3 创建子类对象。就是创建线程对象。
1.4 调用strat方法。开启线程并让线程执行，同时还会告诉jvm调用run方法。

为什么要这么做？
继承Thread类：因为Thread类描述线程事物，具备线程应该有的功能。
那为什么不直接创建Thread类的对象呢？
Thread t1 = new Thread();
t.strat();//这么做没有错，但是该strat调用的是Thread类中的run方法，
而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让
线程执行的代码。

创建线程的目的是什么？是为了建立单独的执行路径，让多部分代码实现同时执行。
也就是线程创建并执行需要给定代码(线程的任务)。
对于之前所讲的主线程，它的任务定义在了主函数中。
自定义的线程需要执行的任务都定义在run方法中。
Thread类中run方法内部的任务并不是我们所需要的。只要重写这个run方法就行了。
既然Thread类已经定义了线程任务的位置，只要在位置中定义任务代码即可。
所以进行了重写run方法动作。

多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。
进行方法的压栈和弹栈。

当执行线程的任务结束了，线程自动在栈内存中释放了。
当所有的执行线程都结束了，进程就结束了。

//获取线程名称。可以通过Thread类中的一个currentThreadd()方法。怎么获取名称呢？
getName();

Thread.currentThread().getName();

主线程的名称是：main
自定义的线程名称是：Thread-1 线程多个时，数字依次递增。
*/

class Demo extends Thread
{
private String name;
Demo(String name)
{
this.name = name;
}
public void run()
{
//int[] arr = new int[3];
//System.out.println(arr[4]);
for(int x=1;x<=20;x++)
{
System.out.println("name="+name+"....."+Thread.currentThread().getName()+".."+x);
}
}
}

class ThreadDemo1
{
public static void main(String[] args)
{
//创建了两个线程对象。
Demo d1 = new Demo("小强");
Demo d2 = new Demo("旺财");
d2.start();//将d2这个线程开启。
d1.run();//由主线程负责。

/*
线程对象调用run方法和调用start方法的区别？
调用run方法不开启线程，仅是对象调用方法。
调用start开启线程，并让jvm调用run方法在开启的线程中执行。
*/
}
}

//创建线程的第二种方式。
/*
创建线程的第二种方式：使用Runnable接口。
1,定义类实现Runnable接口。//避免了单继承的局限性。
2，覆盖接口中的run方法。将线程任务代码定义到run方法中。
3，创建Thread类的对象。        //只有创建Thread类的对象才可以创建线程。
4，将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
因为线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象。
所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的任务。
5，调用Thread类的strat方法开启线程。

第二种方式实现Runnable接口避免了单继承的局限性。所以，较为常用。
实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。
继承Thread类，线程对象和线程任务耦合在一起，一旦创建Thread类的子类对象，既是线程对象，又有线程任务。
实现Runnable接口，将线程任务单独分离出来封装成对象。类型就是Runnable接口类型。
Runnable接口对线程对象和线程任务解耦。

//通过源代码的形式讲解了一些Runnable接口的子类对象作为参数传递给Thread构造函数的原因。
class Thread{
private Runnable target;

Thread(Runnable traget)
{
this.target = target;
}
public void run() {
if (target != null) {
target.run();
}
}
public void strat()
{
run();
}
}

Demo d = new Demo();//Runnable d = new Demo();
Thread t = new Thread(d);
t.strat();
*/

class Demo implements Runnable
{
private String name;
Demo(String name)
{
this.name = name;
}
//覆盖了接口Runnable的run方法。
public void run()
{
for(int x=1;x<20;x++)
{
System.out.println("name="+name+"....."+Thread.currentThread().getName()+".."+x);
}
}
}
class ThreadDemo2
{
public static void main(String[] args)
{
//创建Runnable子类的对象。注意它并不是线程对象。
Demo d = new Demo("Demo");
//创建Thread类的对象，将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();

System.out.println(Thread.currentThread().getName()+"------>");
}
}

//多线程的安全问题产生及原因以及解决思路
/*
案例：售票的例子。

售票的动作需要同时执行。所以要使用多线程技术。

发生了线程安全问题，出现了错误的数据；0 -1 -2

问题产生的原因：
1，线程任务在操作共享的数据。
2，线程任务操作共享数据的代码有多条（运算有多个）。

解决思路：
只要让一个线程在执行线程任务时，将多条操作共享数据的代码执行完，
在执行过程中，不要让其他线程参与运算就行了。

代码体现：
Java中解决此问题通过代码块来完成的，
这个代码代码块称之为同步代码块 synchronized
格式：
synchronized(对象)
{
//需要被同步的代码。
}

同步好处：同步代码块解决了多线程安全问题。

同步的弊端：
降低了程序的性能。

同步前提：
必须保证多个线程在同步中使用的是同一个锁
解决了什么问题？当多线程安全问题发生时，加入了同步后，问题依旧发生时，
就要通过这个同步的前提来判断同步是否正确。
*/

class Ticket implements Runnable
{
//1，描述票的数量
private int tickets = 100;

//2,售票的动作。这个动作需要被多线程执行，那就是线程任务代码，
//需要定义在run方法中。
//记住，线程任务中通常都有循环结构。
private Object obj = new Object();
public void run()
{
while(true)
{
synchronized(obj)//如果写 new Object() 则用的就不是同一个锁。
{
if(tickets > 0)
{
//要让线程在这里稍停，模拟问题的发生。sleep 看到了 0 -1 -2 这样的错误的数据，这就是传说中的安全问题。
try{Thread.sleep(1);}catch(InterruptedException e){/*未写处理方式，后面讲*/}

System.out.println(Thread.currentThread().getName()+"...."+tickets--);//打印线程名称
}
}
}
}
}

class ThreadDemo3
{
public static void main(String[] args)
{
//1，创建Runnable接口的子类对象。
Ticket t = new Ticket();

//创建四个线程对象。并将Runnable接口的子类对象作为参数传递给Thread的构造函数。
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);

//3，开启四个线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}