学习记录：多线程

于 2020-10-31 15:44:58 发布
阅读量107 收藏
点赞数
分类专栏： 学习记录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PNDUG/article/details/109331702
版权

学习内容：多线程

学习关于多线程的内容（一）

启动一个线程

在此之前再在Linux课上学过关于线程的基础知识，因此比较能够理解

package charactor;

public class TestThread {
		public static void main(String args[]) {
			Hero gareen  = new Hero();
			gareen.name="luna";
			gareen.hp=648;
			gareen.damage=45;
			
			Hero teemo= new Hero();
			teemo.name= "Rainboomk";
			teemo.hp=648;
			teemo.damage=48;
			Hero Aj = new Hero();
			Aj.name="AJ";
			Aj.hp=648;
			Aj.damage=100;
			
			Hero Tw = new Hero();
			Tw.name="Tw";
			Tw.hp=648;
			Tw.damage=99;
			//继承线程类
			/*killThread killThread1 = new killThread(gareen, teemo);
			killThread1.start();
			killThread killThread2 = new killThread(Aj, Tw);
			killThread2.start();*/
			//实现Runnable接口方式
			/*Battle battle1 = new Battle(gareen, teemo);
			new Thread(battle1).start();
			Battle battle2 = new Battle(Aj, Tw);
			new Thread(battle2).start();*/
			//匿名类方式
			Thread t1 = new Thread() {
				public void run() {
					while(!teemo.isDead()) {
						gareen.attackHero(teemo);
					}
				}
			};
			t1.start();
			Thread t2 = new Thread() {
				public void run() {
					while(!Aj.isDead()) {
						Aj.attackHero(Tw);
					}
				}
			};
			t2.start();
			
		}
}

package charactor;

public class Battle implements Runnable{
	private Hero h1;
	private Hero h2;
	public Battle(Hero h1,Hero h2)
	{
		this.h1=h1;
		this.h2=h2;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (!h2.isDead()) {
			h1.attackHero(h2);
		}
	}
	
	
}

package charactor;

public class killThread extends Thread{
	private Hero h1;
	private Hero h2;
	public killThread(Hero h1,Hero h2) {
		this.h1=h1;
		this.h2=h2;
	}
	public void run() {
		while(!h2.isDead()) {
			h1.attackHero(h2);
		}
	}
}

练习

package charactor;

import java.io.File;

public class TestThread {
	public static void recursive(File file, String search)//递归
    {
        if(file.isFile())
        {
            killThread thread1=new killThread(file,search);
            new Thread(thread1).start();
        }
        else if(file.isDirectory())
        {
            File[] fs=file.listFiles();
            for(File f:fs)
            {
                recursive(f,search);
            }
        }
    }
		public static void main(String args[]) {
		File folder = new File("D:wqw");
	        recursive(folder, "soo");
		}
}
public class killThread extends Thread{
	private Hero h1;
	private Hero h2;
	public killThread(Hero h1,Hero h2) {
		this.h1=h1;
		this.h2=h2;
	}
	/*public void run() {
		while(!h2.isDead()) {
			h1.attackHero(h2);
		}
	}*/
	public File file;
    public String search;
    public killThread(File file, String search)
    {
        this.file=file;
        this.search=search;
    }
    public void run(){  //多线程实现
 
         
 
        //同一类中,不同封装方法中,调用其他方法,实例化(创建)方法对象
        String fileContent = readFileContent();
        if (fileContent.contains(search)) { 
            //%S是输出字符串  %n代表换行第二个参数 就是我传入的对象(String类型的字符串) 第三个参数 拿到了File对象的路径和文件名
            //\n是在lunix系统下的换行符 \r\n是在windows系统下的换行符----为了平台通用%n作为两种的整合                  
            System.out.println("进一次循环:");
            System.out.printf("找到子目标字符串: %s , 在文件: %s%n",search,file);
        }               
 
 
        //是目录就遍历,然后递归,获取子目录中包括指定字符串的文件
 
    }
    //读取文件内容方法
    public String readFileContent() {       
        //try(){}小括号内的资源会在try语句结束后自动释放，(对象释放,流资源还在,还是要关的)前提是这些可关闭的资源必须实现 java.lang.AutoCloseable 接口。
        //InputStream 和OutputStream 父类中一定实现了AutoCloseable接口
        //传入的必须是文件才行,否则异常,使用转换流,指定编码集,解决乱码问题
        InputStreamReader fr = null;
        try{
            fr = new InputStreamReader( new FileInputStream(file),"UTF-8");
            char[] all = new char[(int) file.length()];//一次读取file对象目录及子目录中的的所有文件(自定义缓冲区)
            fr.read(all);
            return new String(all);
 
        } catch (IOException e) {
            //不正确直接进入catch(捕捉)异常,并输出
            System.out.println(e.toString()+"转换字符流对象创建失败");
            return null;
 
        }finally{
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    throw new RuntimeException();//运行时异常(读取文件内容时发生的异常)
                }
            }
        }
    }
}

Java 常见的线程方法

sleep
当前线程暂停

join
加入到当前线程中，加入的进程结束后该进程才会往下走

setPriority
线程优先级

yield
临时暂停

setDaemon
守护线程

练习

package charactor;

import java.io.File;

public class TestThread {
public static void main(String args[]) {
			Hero gareen  = new Hero();
			gareen.name="luna";
			gareen.hp=648;
			gareen.damage=45;
			
			Hero teemo= new Hero();
			teemo.name= "Rainboomk";
			teemo.hp=648;
			teemo.damage=48;
			Hero Aj = new Hero();
			Aj.name="AJ";
			Aj.hp=648;
			Aj.damage=100;
			
			Hero Tw = new Hero();
			Tw.name="Tw";
			Tw.hp=648;
			Tw.damage=99;
			Thread t1= new Thread(){
	            public void run(){
	                while(true){
	                    gareen.bodong();
	                    try{
							Thread.sleep(3000);
						}catch(InterruptedException e) {
							e.printStackTrace();
						}
	                }              
	            }
	        };
	        	        t1.start();
	        //t2.start();
		}
}

同步

两个进程同步进行时，将有几率产生“脏数据”

而解决的方法是用synchronized同步对象
同时synchronized也可以直接同步方法，那么外部线程访问gareen的方法，就不需要额外使用synchronized 了 。

练习

package charactor;

import java.util.HashMap;
import java.util.LinkedList;
 
import charactor.Hero;
   
public class StackT<T> {
	
	LinkedList<T>  values = new LinkedList<T>();
    public synchronized void push(T t) {
        values.addLast(t);
    }
   
    public synchronized T pull() {
        return values.removeLast();
    }
   
    public synchronized T peek() {
        return values.getLast();
    }
       
    public synchronized static void main(String[] args) {
        //在声明这个Stack的时候，使用泛型<Hero>就表示该Stack只能放Hero
        StackT<Hero> heroStack = new StackT<>();
        heroStack.push(new Hero());
        //不能放Item
        //heroStack.push(new Item());
         
        //在声明这个Stack的时候，使用泛型<Item>就表示该Stack只能放Item
        StackT<Item> itemStack = new StackT<>();
        itemStack.push(new Item());
        //不能放Hero
        //itemStack.push(new Hero());
    }
   
}

线程安全的类

HashMap和Hashtable的区别
hashmap可以存放 null，不是线程安全的类
Hashtable不可以存放 null，是线程安全的类

StringBuffer和StringBuilder的区别
StringBuilder 是非线程安全的类
StringBuffer 是线程安全的类

ArrayList和Vector的区别
Vector是线程安全的类
ArrayList是非线程安全的。

把非线程安全的集合转换为线程安全可以通过Collections.synchronizedList把ArrayList转换为线程安全的List。

练习

public class StackT<T> {
	
	//LinkedList<T>  values = new LinkedList<T>();
	List<Integer> values=new ArrayList<>();
	List<Integer> list2=Collections.synchronizedList(values);
	//以下省略
	}

死锁

两个进程同时在等待对方完成、释放对象，结果将一直等待导致死锁。

package charactor;

import java.io.File;

public class TestThread {
	
		final Object someObject1 = new Object();
        final Object someObject2 = new Object();
        final Object someObject3 = new Object();
           
        Thread t1 = new Thread(){
            public void run(){
                try {
                    synchronized (someObject1)
                    {
                        System.out.println("线程" + this.getName() + "占有资源1");
                        Thread.sleep(1000);
                        System.out.println("线程" + this.getName() + "试图占有资源2");
                        synchronized (someObject2)
                        {
                            System.out.println("线程" + this.getName() + "占有资源2");
                        }
                    }
 
                    System.out.println(this.getName() + "结束，释放所有资源");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t1.setName(" t1");
        t1.start();
        Thread t2 = new Thread(){
   
            public void run(){
                try {
                    synchronized (someObject2)
                    {
                        System.out.println("线程" + this.getName() + "占有资源2");
                        Thread.sleep(1000);
                        System.out.println("线程" + this.getName() + "试图占有资源3");
                        synchronized (someObject3)
                        {
                            System.out.println("线程" + this.getName() + "占有资源3");
                        }
                    }
 
                    System.out.println(this.getName() + "结束，释放所有资源");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t2.setName(" t2");
        t2.start();
         
        Thread t3 = new Thread(){
               
            public void run(){
                try {
                    synchronized (someObject3)
                    {
                        System.out.println("线程" + this.getName() + "占有资源3");
                        Thread.sleep(1000);
                        System.out.println("线程" + this.getName() + "试图占有资源1");
                        synchronized (someObject1)
                        {
                            System.out.println("线程" + this.getName() + "占有资源1");
                        }
                    }
 
                    System.out.println(this.getName() + "结束，释放所有资源");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t3.setName(" t3");
        t3.start();
	}
}

交互

使用交互是为了提高进程的效率和性能，减少CPU的占用
this.wait()表示 让占有this的线程等待，并临时释放占有
this.notify() 表示通知那些等待在this的线程可以继续了

练习

package charactor;

import java.io.File;

public class TestThread {
	public static void main(String args[]) {
	final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 616;
             
        Thread t1 = new Thread(){
            public void run(){
                while(true){
                    gareen.hurt();
                     
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
   
            }
        };
   
        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    gareen.recover();
   
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
   
            }
        };
        t2.start();
        t1.start();
	}
}

线程池

以我的理解，线程池的出现是为了减少过多的线程的创建启用，而启用线程池，在不使用的时候进行等待，需要的时候再去唤醒

package multiplethread;
  
import java.util.LinkedList;
  
public class ThreadPool {
  
    int threadPoolSize;
    
    LinkedList<Runnable> tasks = new LinkedList<Runnable>();
 
  
    public ThreadPool() {
        threadPoolSize = 10;
        synchronized (tasks) {
            for (int i = 0; i < threadPoolSize; i++) {
                new TaskConsumeThread("任务消费者线程 " + i).start();
            }
        }
    }
  
    public void add(Runnable r) {
        synchronized (tasks) {
            tasks.add(r);
            tasks.notifyAll();
        }
    }
  
    class TaskConsumeThread extends Thread {
        public TaskConsumeThread(String name) {
            super(name);
        }
  
        Runnable task;
  
        public void run() {
            System.out.println("启动： " + this.getName());
            while (true) {
                synchronized (tasks) {
                    while (tasks.isEmpty()) {
                        try {
                            tasks.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    task = tasks.removeLast();
                    // 允许添加任务的线程可以继续添加任务
                    tasks.notifyAll();
  
                }
                System.out.println(this.getName() + " 获取到任务，并执行");
                task.run();
            }
        }
    }
  
}

Lock对象

lock对象的功能与synchronized类似
不同点： lock必须用unlock方法进行手动释放，一半会将unloc放在finally中。
同时，lock提供了trylock方法，使其可以尝试占用
lock对象的线程交互通过lock对象得到一个Condition对象，然后分别调用这个Condition对象的：await, signal,signalAll 方法

package charactor;

import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.text.SimpleDateFormat;

public class TestThread2 {
	public static String now() {
		return new SimpleDateFormat("HH:mm:ss").format(new Date());
	}
	public static void log(String msg) {
		System.out.printf("%s %s %s %n",now(),Thread.currentThread().getName(),msg);
	}
	public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		Condition condition = lock.newCondition();
		Thread t1 = new Thread() {
            public void run() {
                try {
                    log("线程启动");
                    log("试图占有对象：lock");
 
                    lock.lock();
 
                    log("占有对象：lock");
                    log("进行5秒的业务操作");
                    Thread.sleep(5000);
                    log("临时释放对象 lock， 并等待");
                    condition.await();
                    log("重新占有对象 lock，并进行5秒的业务操作");
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    log("释放对象：lock");
                    lock.unlock();
                }
                log("线程结束");
            }
        };
		t1.setName("t1");
        t1.start();
        try {
            //先让t1飞2秒
            Thread.sleep(2000);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        Thread t2 = new Thread() {
        	 
            public void run() {
            	boolean locked = false;
                try {
                    log("线程启动");
                    log("试图占有对象：lock");
                    lock.lock();
            
                    	log("占有对象：lock");
                        log("进行5秒的业务操作");
                        Thread.sleep(5000);
                        log("唤醒等待中的线程");
                        condition.signal();
 
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                	
                	if(locked){
                        log("释放对象：lock");
                        lock.unlock();
                    }
                }
                log("线程结束");
            }
        };
        t2.setName("t2");
        t2.start();
	}
}

原子访问

原子性操作即不可中断的操作
原子性操作本身是线程安全的
步骤 1. 取 i 的值
步骤 2. i + 1
步骤 3. 把新的值赋予i
这三个步骤，每一步都是一个原子操作，但是合在一起，就不是原子操作。就不是线程安全的。
换句话说，一个线程在步骤1 取i 的值结束后，还没有来得及进行步骤2，另一个线程也可以取 i的值了。
这也是分析同步问题产生的原因 中的原理。
i++ ，i--， i = i+1 这些都是非原子性操作。
只有int i = 1,这个赋值操作是原子性的。
JDK6 以后，新增加了一个包java.util.concurrent.atomic，里面有各种原子类，比如AtomicInteger。
而AtomicInteger提供了各种自增，自减等方法，这些方法都是原子性的。 换句话说，自增方法 incrementAndGet 是线程安全的，同一个时间，只有一个线程可以调用这个方法。

以上内容转自how2j网站，我并未完全理解，只差不多意会，无法用语言具体描述。

PNDUG
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值