有关java5以后的线程

办法一
承继于Thread类
/**
* 多线程的创立，办法一：承继于Thread类
* 1. 创立一个承继于Thread类的子类
* 2. 重写Thread类的run() –> 将此线程履行的操作声明在run()中
* 3. 创立Thread类的子类的目标
* 4. 经过此目标调用start()
*
* 比如：遍历100以内的所有的偶数
*
* @author shkstart
* @create 2019-02-13 上午 11:46
*/ //1. 创立一个承继于Thread类的子类 class MyThread extends Thread { //2. 重写Thread类的run() @Override public void run() { for (int i = 0; i < 100; i++) { if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + “:” + i);
}
}
} } public class ThreadTest { public static void main(String[] args) { //3. 创立Thread类的子类的目标 MyThread t1 = new MyThread(); //4.经过此目标调用start():①发动当时线程 ② 调用当时线程的run() t1.start(); //问题一：咱们不能经过直接调用run()的办法发动线程。 // t1.run(); //问题二：再发动一个线程，遍历100以内的偶数。不能够还让现已start()的线程去履行。会报IllegalThreadStateException // t1.start(); //咱们需求重新创立一个线程的目标 MyThread t2 = new MyThread();
t2.start(); //如下操作仍然是在main线程中履行的。 for (int i = 0; i < 100; i++) { if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + “:” + i + “***********main()************”);
}
}
}
}
办法二
完成Runnable接口
/**
* 创立多线程的办法二：完成Runnable接口
* 1. 创立一个完成了Runnable接口的类
* 2. 完成类去完成Runnable中的笼统办法：run()
* 3. 创立完成类的目标
* 4. 将此目标作为参数传递到Thread类的结构器中，创立Thread类的目标
* 5. 经过Thread类的目标调用start() * * * 比较创立线程的两种办法。
* 开发中：优先选择：完成Runnable接口的办法
* 原因：1. 完成的办法没有类的单承继性的局限性
* 2. 完成的办法更合适来处理多个线程有同享数据的状况。
*
* 联系：public class Thread implements Runnable
* 相同点：两种办法都需求重写run(),将线程要履行的逻辑声明在run()中。
*
* @author shkstart
* @create 2019-02-13 下午 4:34
*/ //1. 创立一个完成了Runnable接口的类 class MThread implements Runnable{ //2. 完成类去完成Runnable中的笼统办法：run() @Override public void run() { for (int i = 0; i < 100; i++) { if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + “:” + i);
}
}
}
} public class ThreadTest1 { public static void main(String[] args) { //3. 创立完成类的目标 MThread mThread = new MThread(); //4. 将此目标作为参数传递到Thread类的结构器中，创立Thread类的目标 Thread t1 = new Thread(mThread);
t1.setName(“线程1”); //5. 经过Thread类的目标调用start():① 发动线程 ②调用当时线程的run()–>调用了Runnable类型的target的run() t1.start(); //再发动一个线程，遍历100以内的偶数 Thread t2 = new Thread(mThread);
t2.setName(“线程2”);
t2.start();
}
}
办法一与办法二比较推荐运用办法二，办法二完成的办法没有类的单承继性的局限性，完成的办法更合适来处理多个线程有同享数据的状况。
测验Thread中的常用办法：
/**
* 测验Thread中的常用办法：
* 1. start():发动当时线程；调用当时线程的run()
* 2. run(): 通常需求重写Thread类中的此办法，将创立的线程要履行的操作声明在此办法中
* 3. currentThread():静态办法，返回履行当时代码的线程
* 4. getName():获取当时线程的姓名
* 5. setName():设置当时线程的姓名
* 6. yield():释放当时cpu的履行权
* 7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全履行完今后，线程a才
* 完毕阻塞状态。
* 8. stop():已过期。当履行此办法时，强制完毕当时线程。
* 9. sleep(long millitime):让当时线程“睡觉”指定的millitime毫秒。在指定的millitime毫秒时刻内，当时
* 线程是阻塞状态。
* 10. isAlive():判别当时线程是否存活
*
*
* 线程的优先级：
* 1.
* MAX_PRIORITY：10
* MIN _PRIORITY：1
* NORM_PRIORITY：5 –>默许优先级
* 2.怎么获取和设置当时线程的优先级：
* getPriority():获取线程的优先级
* setPriority(int p):设置线程的优先级
*
* 阐明：高优先级的线程要抢占低优先级线程cpu的履行权。可是仅仅从概率上讲，高优先级的线程高概率的状况下
* 被履行。并不意味着只有当高优先级的线程履行完今后，低优先级的线程才履行。
*
*
* @author shkstart
* @create 2019-02-13 下午 2:26
*/ class HelloThread extends Thread{ @Override public void run() { for (int i = 0; i < 100; i++) { if(i % 2 == 0){ // try { // sleep(10); // } catch (InterruptedException e) { // e.printStackTrace(); // } System.out.println(Thread.currentThread().getName() + “:” + Thread.currentThread().getPriority() + “:” + i);
} // if(i % 20 == 0){ // yield(); // } }
} public HelloThread(String name){ super(name);
}
} public class ThreadMethodTest { public static void main(String[] args) {
HelloThread h1 = new HelloThread(“Thread：1”); // h1.setName(“线程一”); //设置分线程的优先级 h1.setPriority(Thread.MAX_PRIORITY);
h1.start(); //给主线程命名 Thread.currentThread().setName(“主线程”);
Thread.currentThread().setPriority(Thread.MIN_PRIORITY); for (int i = 0; i < 100; i++) { if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + “:” + Thread.currentThread().getPriority() + “:” + i);
} // if(i == 20){ // try { // h1.join(); // } catch (InterruptedException e) { // e.printStackTrace(); // } // } } // System.out.println(h1.isAlive()); }
}
创立线程的办法三：
完成Callable接口。 — JDK 5.0新增
import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /**
* 创立线程的办法三：完成Callable接口。 — JDK 5.0新增
*
*
* 怎么理解完成Callable接口的办法创立多线程比完成Runnable接口创立多线程办法强壮？
* 1. call()能够有返回值的。
* 2. call()能够抛出异常，被外面的操作捕获，获取异常的信息
* 3. Callable是支持泛型的
*
* @author shkstart
* @create 2019-02-15 下午 6:01
*/ //1.创立一个完成Callable的完成类 class NumThread implements Callable{ //2.完成call办法，将此线程需求履行的操作声明在call()中 @Override public Object call() throws Exception { int sum = 0; for (int i = 1; i <= 100; i++) { if(i % 2 == 0){
System.out.println(i);
sum += i;
}
} return sum;
}
} public class ThreadNew { public static void main(String[] args) { //3.创立Callable接口完成类的目标 NumThread numThread = new NumThread(); //4.将此Callable接口完成类的目标作为传递到FutureTask结构器中，创立FutureTask的目标 FutureTask futureTask = new FutureTask(numThread); //5.将FutureTask的目标作为参数传递到Thread类的结构器中，创立Thread目标，并调用start() new Thread(futureTask).start(); try { //6.获取Callable中call办法的返回值 //get()返回值即为FutureTask结构器参数Callable完成类重写的call()的返回值。 Object sum = futureTask.get();
System.out.println(“总和为：” + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
办法四
运用线程池
/**
* 创立线程的办法四：运用线程池
*
* 好处：
* 1.进步响应速度（减少了创立新线程的时刻）
* 2.降低资源消耗（重复利用线程池中线程，不需求每次都创立）
* 3.便于线程办理
* corePoolSize：中心池的大小
* maximumPoolSize：最大线程数
* keepAliveTime：线程没有使命时最多坚持多长时刻后会停止
*
*
* 面试题：创立多线程有几种办法？四种！
* @author shkstart
* @create 2019-02-15 下午 6:30
*/ class NumberThread implements Runnable{ @Override public void run() { for(int i = 0;i <= 100;i++){ if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + “: ” + i);
}
}
}
} class NumberThread1 implements Runnable{ @Override public void run() { for(int i = 0;i <= 100;i++){ if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + “: ” + i);
}
}
}
} public class ThreadPool { public static void main(String[] args) { //1. 供给指定线程数量的线程池 ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; //设置线程池的特点 // System.out.println(service.getClass()); // service1.setCorePoolSize(15); // service1.setKeepAliveTime(); //2.履行指定的线程的操作。需求供给完成Runnable接口或Callable接口完成类的目标 service.execute(new NumberThread());//合适适用于Runnable service.execute(new NumberThread1());//合适适用于Runnable // service.submit(Callable callable);//合适运用于Callable //3.封闭连接池 service.shutdown();
}
}