Java 并发--线程创建

随着处理器的多核化，为提高处理器的资源利用率应用程序的并发变应运而生了.现在的操作系统是多任务操作系统，多线程是实现多任务的一种方式。

进程是指一个内存中运行的应用程序，每个进程都有自己独立的内存空间，一个进程可以启动多个线程。比如java.exe是一个进程，而java.exe中可以运行多个线程。进程中的多个线程共享进程的内存。

一：多线程的实现方法有二种

1. 实现Runnable接口

2. 继承Thread类

一个Thread类实例只是一个对象，与java中的其他对象一样，具有变量和方法，生死于堆上。java中每个线程都有一个调用栈，一个java应用总是从main方法开始运行的，main被称作为这个进程中的主线程。

线程分类：

1. 用户线程：当所有用户线程执行完毕的时候JVM自动关闭

2. 守护线程：由于守护线程不独立于JVM，守护线程一般都是由操作系统或用户自己创建的

创建线程方式应该没有直接贴代码来得更直接的了。

　　实现Runnable接口方式创建线程

package NewThread;

public class DoSomething implements Runnable {
    
    private String name;
    public DoSomething (String name) {
        this.name = name;
    }
    
    //重写run方法，此方法里面实现要执行的内容
    @Override
    public void run() {
        // TODO Auto-generated method stub
            for(long k = 0; k < 100; k++)
            {
                //Thread.currentThread() 获取当前线程的对象
                //Thread.currentThread().getName() 获取当前线程的名字
                System.out.println(Thread.currentThread().getName()+"  :  "+ name+":"+k);
            }
    }

}

 

package NewThread;

public class TestRunnable {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        DoSomething ds1 = new DoSomething("张三");   
        DoSomething ds2 = new DoSomething("李四");    
        DoSomething ds3 = new DoSomething("王二");
        
        Thread t1 = new Thread(ds1);
        Thread t2 = new Thread(ds2);
        Thread t3 = new Thread(ds3);
        
        //分别启动创建的三个线程
        t1.start();    
        t2.start();
        t3.start();
        
        System.out.println("主线程执行完成");
    }

}

运行结果如下 

Thread-0  :  张三:0
Thread-2  :  王二:0
主线程执行完成
Thread-1  :  李四:0
Thread-2  :  王二:1
Thread-0  :  张三:1
Thread-0  :  张三:2
Thread-0  :  张三:3
Thread-2  :  王二:2
Thread-1  :  李四:1
Thread-2  :  王二:3
Thread-0  :  张三:4
Thread-2  :  王二:4
Thread-1  :  李四:2
Thread-2  :  王二:5

发现打印的结果不是连续的，而且每次运行的结果都是不尽相同的；因为多个线程都是以轮流坐庄的方式占用CUP的，具体怎么坐庄以JVM线程调度程序为准

如果是单核处理器的话就没有必要写多线程的程序了，因为CUP每一时刻都只会把资源交给一个线程，而且还会无谓的增加栈的切换。

 

　　下面介绍另一程序方式创建线程，继承Thread类创建线程

package NewThread;

public class DoSomething_Thread extends Thread {

    private String name;
    public DoSomething_Thread (String name) {
        this.name = name;
    }
    
    //重写run方法，此方法里面实现要执行的内容
    @Override
    public void run() {
        // TODO Auto-generated method stub
            for(long k = 0; k < 100; k++)
            {
                //Thread.currentThread() 获取当前线程的对象
                //Thread.currentThread().getName() 获取当前线程的名字
                System.out.println(Thread.currentThread().getName()+"  :  "+ name+":"+k);
            }
    }
}

package NewThread;

public class TestThread {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//实例化线程
		Thread t1 = new DoSomething_Thread("张三");
		Thread t2 = new DoSomething_Thread("李四");
		Thread t3 = new DoSomething_Thread("王二");
		
		//启动线程
		t1.start();
		t2.start();
		t3.start();
		
		System.out.println("主线程执行完毕!");
	}

}

运行结果如下

Thread-1  :  李四:0
Thread-2  :  王二:0
主线程执行完毕!
Thread-0  :  张三:0
Thread-2  :  王二:1
Thread-1  :  李四:1
Thread-1  :  李四:2
Thread-1  :  李四:3
Thread-1  :  李四:4
Thread-1  :  李四:5
Thread-2  :  王二:2
Thread-0  :  张三:1

线程创建就到此为止了。

线程状态：

线程在一定条件下，状态会发生变化。线程变化的状态转换图如下：

　　1、新建状态(New)：新创建了一个线程对象。

　　2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

　　3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。

　　4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

　　(一)、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。

　　(二)、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

　　(三)、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

　　5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

注意：

1. 线程的名字是可以设置，若不设置则JVM会给线程一个名字；

2. 线程的结束是以run方法执行完毕为准；

3. 若线程启动了，它将不能再重新启动，线程只能被启动一次。

4. 线程的高度是JVM的一部分，在一个CUP的机器上实际上一次只能运行一个线程，一次只有一个线程栈被执行。JVM线程调度程序决定运行哪一个处于可执行状态下的线程

5. 尽管我们无法控制线程但我们可以通过别的方式来影响线程调试的方式

 二：阻止线程执行

  对于线程的阻止，在不考虑IO阻塞的情况下，有三种方式阻止线程执行

1. 睡眠：Thread.sleep(long millis)和Thread.sleep(long millis,int nanos); 

　　a. 线程睡眠是帮助所有线程获得运行机会的最好方法

　　b.线程睡眠到期后会自动苏醒，并返回可运行状态，而不是运行状态，所以说当线程苏醒后并不能保证线程会立刻回到运行状态

　　c.sleep()只能控制当前正在运行的线程

　　d.若当前线程占用了锁，那么sleep是不会释放当前锁的

package NewThread;

public class DoSomething_Thread extends Thread {

    private String name;
    public DoSomething_Thread (String name) {
        this.name = name;
    }
    
    //重写run方法，此方法里面实现要执行的内容
    @Override
    public void run() {
        // TODO Auto-generated method stub
            for(long k = 0; k < 100; k++)
            {
                //Thread.currentThread() 获取当前线程的对象
                //Thread.currentThread().getName() 获取当前线程的名字
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"  :  "+ name+":"+k);
            }
    }
}

 

package NewThread;

public class TestThread {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //实例化线程
        Thread t1 = new DoSomething_Thread("张三");
        Thread t2 = new DoSomething_Thread("李四");
        Thread t3 = new DoSomething_Thread("王二");
        
        //启动线程
        t1.start();
        t2.start();
        t3.start();
        
        System.out.println("主线程执行完毕!");
    }

}

输出结果：这里我只把输出结果的部分贴出来了

主线程执行完毕!
Thread-1  :  李四:0
Thread-0  :  张三:0
Thread-2  :  王二:0
Thread-0  :  张三:1
Thread-1  :  李四:1
Thread-2  :  王二:1
Thread-0  :  张三:2
Thread-1  :  李四:2
Thread-2  :  王二:2
Thread-0  :  张三:3
Thread-2  :  王二:3
Thread-1  :  李四:3
Thread-0  :  张三:4
Thread-2  :  王二:4

分析结果可以看出每个线程都是循环得到cpu资源，这可能是因为每运行到一个线程都会sleep然后cpu资源换成了其他线程，从中可以看出一个线程不会连续打印二次。

 

2.线程的优先级和线程让步yield()

　　a. 线程的让步是通过yield方法实现的，作用为暂停当前正在运行的线程对象，并执行其他线程，那我们先来了解一下线程的优先级。每个线程都有优先级，优先级的范围是

0~10之间，JVM线程的调度是基于优先级的抢先机制。一般情况下当前运行的线程的优先级是最大的，但这并不是绝对的。所以在设计多线程程序的时候也不能完全依赖于线程的优先级的设置。

  

package NewThread;

public class TestThread {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //实例化线程
        Thread t1 = new DoSomething_Thread("张三");
        Thread t2 = new DoSomething_Thread("李四");
        Thread t3 = new DoSomething_Thread("王二");
        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");
        //启动线程
        
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.NORM_PRIORITY);
        t3.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        
        t2.start();
        t3.start();
        
        System.out.println("主线程执行完毕!");
    }

}

可以看看运行的结果，发现每次第一个运行的线程都不一定是优先级最高的线程，所以说依靠优先级设置线程的调度是很不可靠的

　　b. Thread.yield方法的作用是为使当前运行的线程回到可执行的状态，使具有相同优先级的其他线程得以执行的机会。但使用yield方法也是不可靠的，因为此线程仍然有可能被JVM调度程序所命中而继续执行。这里yield与sleep的不同处是sleep的线程只有等到苏醒后才有可能会被选中，在睡眠之内肯定是让别的线程运行的。

3. join方法

  join方法是让一个线程B加入到另外一个线程A的尾部，在A执行完成之前，B线程是不能运行的

package NewThread;

public class TestThread {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //实例化线程
        Thread t1 = new DoSomething_Thread("张三");
        Thread t2 = new DoSomething_Thread("李四");
        Thread t3 = new DoSomething_Thread("王二");
        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");
        //启动线程
        t1.start();    
        t2.start();
        t3.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("主线程执行完毕!");
    }

}

执行后可以发现，只有当线程1执行完成后才能主线程才会执行完毕，若把t1.join改成t1.join(10)则有可能会出现t1线程没有执行完毕主线程就已经执行完毕了，因为主线程会等待t1线程10毫秒，若过了10毫秒主线程也会等得不耐烦的，自己就去执行了。

三：线程的同步与锁

为了防止多个线程同时操作一个对象，从而对数据造成破坏。这方面就不多介绍了直接上例子吧