javaSE_多线程

线程的创建和启动：

A：继承Thread类创建线程

1.定义Thread类的子类，并重写run方法。

2.创建对象，调用start方法启动线程.

 

B：实现Runnable接口来创建线程

1.创建一个类实现Runnable接口，并重写run方法。

2.创建类对象，并以此实例作为Thread的target来创建Thread对象。

3.调用Thread对象的start方法启动线程。

 

1. Thread

 

public class MyThread extends Thread{

private int _count;

public MyThread(int count){

_count = count;

}

@Override

public void run() {

for (int i = 1; i <= _count; ++i){

System.out.println(getName() + " : " + i);

}

}

}

public class UseThread {

public static void main(String[] args) {

System.out.println("--main----start-------");

Thread thread1 = new MyThread(22);

thread1.start();

Thread thread2 = new MyThread(19);

thread2.start();

System.out.println("--main----finish-------");

// thread2.interrupt();// 终止线程

}

}

输出：

--main----start-------

--main----finish-------

Thread-0 : 1

Thread-0 : 2

。。。

Thread-1 : 13

Thread-0 : 20

Thread-0 : 21

Thread-1 : 14

Thread-0 : 22

Thread-1 : 15

Thread-1 : 16

Thread-1 : 17

Thread-1 : 18

Thread-1 : 19

 

2. Runnable

 

public class MyRunnable implements Runnable{

private Integer _ticket;

public MyRunnable(int ticket){

_ticket = ticket;

}

@Override

public void run() {

for (int i = 1; i <= 7; i++){

//synchronized (_ticket ) {

if (_ticket > 0){

System.out.println(Thread.currentThread().getName() + " : " + _ticket--);

}

else{

System.out.println(Thread.currentThread().getName() + " : " + "no ticket");

}

}

}

}

MyRunnable run = new MyRunnable(10);

Thread thread1 = new Thread(run);

Thread thread2 = new Thread(run);

thread1.start();

thread2.start();

输出：

Thread-0 : 10

Thread-1 : 9

Thread-0 : 8

Thread-0 : 6

Thread-0 : 5

Thread-0 : 4

Thread-0 : 3

Thread-0 : 2

Thread-1 : 7

Thread-1 : 1

Thread-1 : no ticket

Thread-1 : no ticket

Thread-1 : no ticket

Thread-1 : no ticket

一共有10张票，两个线程各自循环减票，最后一起将10张票减完。可以理解为定义了一个全局对象，两个线程都访问此对象，共同消耗其成员计数。所以它并不保证各线程不会输出同一张票。

但是上面的代码要注意，如果一个线程中if(_ticket>0)执行完后，在输出之前，此时另一线程正好也执行到if语句，就会导致同时输出同一张票。

为了验证此问题，在if后面，_ticket--之前sleep（200）；

if (_ticket > 0){

System.out.println(Thread.currentThread().getName() + " : " + _ticket);

try {

Thread.sleep(200);

} catch (InterruptedException e) {

e.printStackTrace();

}

_ticket--;

}

else{

System.out.println(Thread.currentThread().getName() + " : " + "no ticket");

}

输出：

Thread-0 : 10

Thread-1 : 10

Thread-1 : 9

Thread-0 : 9

Thread-1 : 7

Thread-0 : 7

Thread-1 : 6

Thread-0 : 6

Thread-1 : 4

Thread-0 : 4

Thread-1 : 3

Thread-0 : 3

Thread-1 : 2

Thread-0 : 2

从结果来看，确实验证了上面的话，它并不保证各线程不会重复处理。