Java多线程的一些小知识点

多线程之线程栈

package javabasis.thread;

/**
 * Created by admin on 2017/2/14.
 */
public class basicThread extends Thread{
    public static void main(String[] args) {
        thread1 t1 = new thread1();
        t1.start();
        thread2 t2 = new thread2();
        t2.start();
        System.out.println(4/0);
        System.out.println(Thread.currentThread().getName());
    }

}
class thread1 extends Thread{
    private int[] arr = new int[3];
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(arr[3]);
            System.out.println(Thread.currentThread().getName());
        }
    }
}
class thread2 extends Thread{
    @Override
    public void run() {
        System.out.println("当前线程正在执行");
    }
}

运行结果如下：

当前线程正在执行
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at javabasis.thread.basicThread.main(basicThread.java:12)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)
Exception in thread "Thread-0" java.lang.ArrayIndexOutOfBoundsException: 3
	at javabasis.thread.thread1.run(basicThread.java:22)

以上结果说明，每个线程是相互独立的，一个线程的介绍不会影响另一个线程开启多线程之后，会产生一个新的线程栈

java.lang.illegalthreadstateexception

直接上代码：

 thread1 t = new thread1();
        t.start();
        t.start();

运行结果如下：

Exception in thread "main" java.lang.IllegalThreadStateException
	at java.lang.Thread.start(Thread.java:705)
	at javabasis.thread.basicThread.main(basicThread.java:10)	

根据错误进行定位，主函数中第二次尝试启动线程的做法是非法的

查阅资料显示原因是这样的：当调用第一个线程结束后，线程t已经处于死亡状态，故无法再次修改该线程的状态

线程的数据共享

这是一个卖票的小案例，先给出代码

1.使用Thread方法

class Ticket extends Thread{
    private int num = 10;
    @Override
    public void run() {
        sale();
    }
    public void sale(){
        while (true) {
            if(num > 0){
                //System.out.println(Thread.currentThread().getName());
                System.out.println("这是第"+num--+"张票");
            }
        }
    }

Ticket t1 = new Ticket();
    	 t1.start();
      Ticket t2 = new Ticket();
      t2.start();
      Ticket t3 = new Ticket();
      t3.start();

实验的结果就不详细展示了，一共买了30张票，出现这个现象的原因是，每次开启新的线程是，都会创建新的线程对象，因此每个线程对象都会有自己的成员变量num

2.使用Runnable方法

Ticket ticket = new Ticket();
        new Thread(ticket).start();
        new Thread(ticket).start();

在这种方法中，我们把线程任务封装在了实现Runnable的接口ticket中，而创建的两个线程都是用来操作ticket的属性和方法的，因此很容易实现了数据共享。

线程安全问题

在上面的例子当中，肯出现下面的结果:

这是第2张票
这是第1张票
这是第0张票
这是第-1张票

为什么会出现这样的结果呢？结合run（）的实现过程来看：

public void run(){
        while (true) {
            if(num > 0){
                try {
                    Thread.sleep(10);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println("这是第"+num-- +"张票");
            }
        }
    }

当线程1执行到if判断后，进入休眠状态，此时num =1；休眠过程中线程2从休眠过程中醒来，执行到了num--语句，此时会打印出“ 这是第1张票”，num的值变为0，然后线程2结束，线程1执行打印语句，结构就会是“这是第0张票”。如果存在线程3的话，便可能出现-1。

线程安全问题产生的原因：

1、多个数据在操作共享的数据

2、操作共享数据的代码有多条

总结起来就是，当一个线程在执行共享数据的多条代码时，其他线程参与了运算

因此一个很朴实的解决该问题的思路就是，禁止多个线程同时操作同一块代码块。

这就是所谓的加锁机制