Java多线程

//继承Thread类创建线程
public class MyThread extends Thread{
    public void run(){
        for(int i=0;i){
    System.out.println(Thread.currentThread().getName());
        }
    }
}
public static void main(String[] args) {
        MyThread mt = new MyThread();
//需使用start()方法启动线程，如果直接调用线程中run()方法会:
        //1.只有主线程一条执行路径2.依次调用了两次run()方法
        mt.start();}

//实现Runnable接口创建线程
public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for(int i=0;i){
            System.out.println(Thread.currentThread().getName());
        }
    }
public static void main(String[] args) {
    
        //创建线程对象
        MyRunnable mr = new MyRunnable();
        Thread t = new Thread(mr);
        t.start();
    }

public class MyThread implements Callable {
    
    @Override
    public Integer call() throws Exception {
System.out.println("子线程:"+Thread.currentThread().getName());
        return null;
    }
}
public class Test {
    public static void main(String[] args) {
        FutureTask ft = new FutureTask(new MyThread());
        Thread t = new Thread(ft,"01");
        System.out.println("主线程:"+Thread.currentThread().getName());
        t.start();
    }
}

public class CallableThreadTest implements Callable {
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask ft = new FutureTask(ctt);  
        for(int i = 0;i )  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}

package demo01;
//子线程在调用son方法的时候一上来就能获取同步监视器this
//父线程在调用father函数的时候一上来就是获取不到
//字父线程执行的四种情况: 子 父  父 子  子子 父父
//wait:Object (导致线程阻塞，并释放对同步监视器的占用 )
//notify:Object (唤醒线程的作用，提示后续等待该锁的线程，可以进行访问)
public class FatherAndSon {
    boolean flag=true;
    
    public void son(){
        synchronized (this) {
            //子一定是先执行的
            if(!flag){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            for (int i = 0; i ) {
                System.out.println("儿子线程执行第"+(i+1)+"次");
            }
            flag=false;//1:把机会让给父线程 2、防止子线程再次执行
            this.notify();
        }
        
    }
    public  void father(){
        synchronized (this) {
            //父是后执行的
            if(flag){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            for (int i = 0; i ) {
                System.out.println("老子线程执行第"+(i+1)+"次");
            }
            flag=true;//1:把机会让给子线程 2、防止父线程再次执行
            this.notify();
        }
        
    }
}

package demo01;

//在Java中什么是所谓的同一资源 static
//只存在一个对象的情况下  ticket 
//多个对象: a.ticket b.ticket c.ticket
//保证一种情况:
//synchronized:方法（整个所修饰的方法体都是线程同步的范围）(this:)====>synchronized(this)
//synchronized:代码块(代码块中的内容是线程同步的范围)
public class Test {
   public static void main(String[] args) throws InterruptedException {
       final FatherAndSon fs=new FatherAndSon();
       
       Thread t1=new Thread(new Runnable(){  
         @Override
         public void run() { //子线程的线程体中
             for (int i = 0; i ) {
                  fs.son();
             }    
         } 
       });
       t1.start();
       
      //父线程的线程体中
        for (int i = 0; i ) {
          fs.father();
       }
   }  
}

/**
 * 
 * 创建自定义线程池
 * 
 * */
public class Test {
    public static void main(String[] args) {
        //创建自定义线程池   尽量保证:任务数不要超过最大线程数+阻塞队列的长度
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5,7,300,TimeUnit.MINUTES,new ArrayBlockingQueue(4));
        
        for(int i=0;i){
            executor.execute(new MyRunnable(i));
            System.out.println("线程池中线程数:"+executor.getPoolSize()+",对列中等待任务执行数:"+executor.getQueue().size()+",已经执行完的任务数:"+executor.getCompletedTaskCount());
        }
        executor.shutdown();
    }
}


class MyRunnable implements Runnable{
    int num;//第几个任务
     
    public MyRunnable(int num) {
        super();
        this.num = num;
    }
    @Override
    public void run() {
       System.out.println("正在执行任务"+num);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("任务"+num+"执行完毕");
    }
    
    
}