Java高并发编程一--什么是线程

1.什么是线程

2.如何启动一个线程

2.1继承Thread

//在java.lang包中定义, 继承Thread类必须重写run()方法
class MyThread extends Thread{
private static int num = 0;

public MyThread(){
num++;
}

@Override
public void run() {
System.out.println("主动创建的第"+num+"个线程");
}
}
/*创建好了自己的线程类之后，就可以创建线程对象了，然后通过start()方法去启动线程。
注意，不是调用run()方法启动线程，run方法中只是定义需要执行的任务，如果调用run方法，
即相当于在主线程中执行run方法，跟普通的方法调用没有任何区别，
此时并不会创建一个新的线程来执行定义的任务。*/
public class Test {
public static void main(String[] args)  {
System.out.println("主线程ID:"+Thread.currentThread().getId());
MyThread thread1 = new MyThread("thread1");
thread1.start();
MyThread thread2 = new MyThread("thread2");
thread2.run();
}
}

class MyThread extends Thread{
private String name;

public MyThread(String name){
this.name = name;
}

@Override
public void run() {
System.out.println("name:"+name+" 子线程ID:"+Thread.currentThread().getId());
}

2.2实现Runnable接口

//在Java中创建线程除了继承Thread类之外，还可以通过实现Runnable接口来实现类似的功能。
//实现Runnable接口必须重写其run方法。
//下面是一个例子：
public class Test {
public static void main(String[] args)  {
System.out.println("主线程ID："+Thread.currentThread().getId());
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();
}
}
class MyRunnable implements Runnable{
public MyRunnable() {
}

@Override
public void run() {
System.out.println("子线程ID："+Thread.currentThread().getId());
}
}
//Runnable的中文意思是“任务”，顾名思义，通过实现Runnable接口，我们定义了一个子任务，
//然后将子任务交由Thread去执行。注意，这种方式必须将Runnable作为Thread类的参数，
//然后通过Thread的start方法来创建一个新线程来执行该子任务。如果调用Runnable的run方法的话，
//是不会创建新线程的，这根普通的方法调用没有任何区别。

//事实上，查看Thread类的实现源代码会发现Thread类是实现了Runnable接口的。

//在Java中，这2种方式都可以用来创建线程去执行子任务，具体选择哪一种方式要看自己的需求。
//直接继承Thread类的话，可能比实现Runnable接口看起来更加简洁，但是由于Java只允许单继承，
//所以如果自定义类需要继承其他类，则只能选择实现Runnable接口。

2.3使用ExecutorService、Callable、Future实现有返回结果的多线程

/**
* 有返回值的线程
*/
@SuppressWarnings("unchecked")
public class Test {
public static void main(String[] args) throws ExecutionException,
InterruptedException {
System.out.println("----程序开始运行----");
Date date1 = new Date();

int taskSize = 5;
// 创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(taskSize);
// 创建多个有返回值的任务
List<Future> list = new ArrayList<Future>();
for (int i = 0; i < taskSize; i++) {
Callable c = new MyCallable(i + " ");
// 执行任务并获取Future对象
Future f = pool.submit(c);
// System.out.println(">>>" + f.get().toString());
list.add(f);
}
// 关闭线程池
pool.shutdown();

// 获取所有并发任务的运行结果
for (Future f : list) {
// 从Future对象上获取任务的返回值，并输出到控制台
System.out.println(">>>" + f.get().toString());
}

Date date2 = new Date();
System.out.println("----程序结束运行----，程序运行时间【"
+ (date2.getTime() - date1.getTime()) + "毫秒】");
}
}

class MyCallable implements Callable<Object> {
private String taskNum;

MyCallable(String taskNum) {
this.taskNum = taskNum;
}

public Object call() throws Exception {
System.out.println(">>>" + taskNum + "任务启动");
Date dateTmp1 = new Date();
Thread.sleep(1000);
Date dateTmp2 = new Date();
long time = dateTmp2.getTime() - dateTmp1.getTime();
System.out.println(">>>" + taskNum + "任务终止");
return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
}
}
/*代码说明：
上述代码中Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。
public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。

public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。
如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的Executor。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，
返回Future。如果Executor后台线程池还没有完成Callable的计算，
这调用返回Future对象的get()方法，会阻塞直到计算完成。*/

3.线程的状态

start()

run()

sleep

Thread

wait

Object

Thread.sleep

Thread.sleep

Thread.sleep

Object.wait

wait

notify/notifyAll

4.上下文切换

5.线程的常用方法

public void start()

public void run()

public final void setName(String name)

public final void setPriority(int priority)

public final void setDaemon(boolean on)

public final void join(long millisec)

public void interrupt()

public final boolean isAlive()

public static void yield()

public static void sleep(long millisec)

public static Thread currentThread()

6.停止线程

暂停线程

7.线程的优先级

public final void setPriority(int newPriority) {
ThreadGroup g;
checkAccess();
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
throw new IllegalArgumentException();
}
if((g = getThreadGroup()) != null) {
if (newPriority > g.getMaxPriority()) {
newPriority = g.getMaxPriority();
}
setPriority0(priority = newPriority);
}
}

//在Java中，线程的优先级分为1~10这10个等级，如果小于1或大于10，
//则JDK抛出异常throw new IllegalArgumentException()。
//JDK中使用3个常量来预置定义优先级的值，代码如下：
public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;
/*线程优先级特性：

继承性
比如A线程启动B线程，则B线程的优先级与A是一样的。
规则性
高优先级的线程总是大部分先执行完，但不代表高优先级线程全部先执行完。
随机性
优先级较高的线程不一定每一次都先执行完。
*/

8.守护线程