1、线程可以驱动任务。任务由实现Runnable接口的类定义。New Thread(Runnable)这段代码就是前面一句话最好的诠释。任何线程都可以启动另外一个线程。
由于所有其他线程都是由Main线程所产生的,所以main线程的优先级相对较高。要区分出任务和线程是不同的概念,是以线程去驱动任务的。
package com.thread.demo;
public class Threademo {
/**
* @param args
*/
public static void main(String[] args) {
Thread thread=new Thread(new Thread1());
thread.start();
System.out.println("sdfsdfsdf");
}
}
class Thread1 implements Runnable{
private final int i=0;
private static int count=10;
public void status(){
System.out.println("the id is: "+count);
}
@Override
public void run() {
while(count--!=0){
status();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
2、关于ExecutorService线程管理器的使用:
package com.thread.demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Executordemo {
public static void main(String[] a) throws InterruptedException{
//ExecutorService为每个任务创建合适的上下文,也就是驱动任务的线程。
ExecutorService service=Executors.newCachedThreadPool();
for(int i=0;i<6;i++){
service.execute(new Thread2());
Thread.sleep(1000);
}
service.shutdown();
}
}
class Thread2 implements Runnable{
private final int i=0;
//共同对同一个资源进行竞争
private static int count=10;
public void status(){
System.out.println("the id is: "+count);
}
@Override
public void run() {
while(count-->0){
status();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
理解存在于代码的注释当中。
3、这段代码与前面一段代码的区别是:这段代码预先为即将执行的任务分配了5个线程,当任务提交到线程中时就不用再去重新分配线程了。减少了分配线程时的开销。
public class Executordemo2 {
/**
* @param args
*/
public static void main(String[] args) {
ExecutorService executor=Executors.newFixedThreadPool(5);
for(int i=0;i<5;i++){
executor.execute(new Thread3());
}
executor.shutdown();
}
}
4、线程管理器只分配了1个线程的情况,导致所有的任务只有根据自己提交的顺序进行执行,代码如下:
package com.thread.demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadDemo {
/**
* @param args
*/
public static void main(String[] args) {
ExecutorService excutor=Executors.newFixedThreadPool(1);
for(int i=0;i<5;i++){
excutor.execute(new Single());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
excutor.shutdown();
}
}
class Single implements Runnable{
private static int i=0;
@Override
public void run() {
i++;
System.out.println("sdfsdf"+i);
}
}
5、Java中的futrue设计模式:
在java中,如果需要设定代码执行的最长时间,即超时,可以用java线程池ExecutorService类配合Future接口来实现。Future接口是JAVA标准API的一部分,在java。Util。concurrent包中。Future接口是java线程Future模式的实现,可以来进行异步计算。
Futrue模式可以这样描述:我有一个任务,提交了Future,future替我完成这个任务,期间我可以干别的任何事。
6、关于futrue以及java中的Callable接口的使用,代码如下:
package com.thread.demo;
import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class FutrueCllasbledemo {
/**
* @param args
* @throws ExecutionException
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService service=Executors.newCachedThreadPool();
ArrayList<Future<String>> arraylist=new ArrayList<Future<String>>();
for(int i=0;i<5;i++){
arraylist.add(service.submit(new Callback()));
}
for(Future<String> future:arraylist){
System.out.println(future.get());
}
service.shutdown();
}
}
class Callback implements Callable<String>{
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "hello";
}
}
7、关于对线程使用sleep演示,由于当前线程挂起,自然导致线程驱动的任务挂起。以下为演示例子:
package com.thread.demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadCompeteDemo {
public static void main(String[] a){
ExecutorService service=Executors.newCachedThreadPool();
service.execute(new Threademo4());
service.execute(new Threademo5());
service.shutdown();
}
}
class Threademo4 implements Runnable{
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("liu");
}
}
class Threademo5 implements Runnable{
@Override
public void run() {
System.out.println("yangyang");
}
}
关于一些重要特性的总结:
线程的优先级将该线程的重要性传递给了调度器。
Excutor线程管理器可以对管理器的线程实行一次性的全部关闭。
创建任务,将线程附着到任务上,以使线程可以驱动任务。
在java中,Thread类并不执行任何操作,它只是驱动他的任务。
Java的线程机制基于来自c的低级的p线程方式。
ThreadFactory工厂通常和ExecutorService 联合使用,通常前者位于后者的构造函数中,ThreadFactory主要为ExecutorService线程管理器产生的线程定制某些行为和属性。