黑马程序员—【Java基础篇】之多线程

最新推荐文章于 2019-08-02 09:39:18 发布
最新推荐文章于 2019-08-02 09:39:18 发布
阅读量789 收藏
点赞数
文章标签： 异常 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WL8721/article/details/45245685
版权
------- android培训 、 java培训 、期待与您交流！ ---------

    这篇如标题，介绍和总结多线程。

    多线程内容总结，主要分一下几大块：一、进程；二、线程（例：FlashGet）；三、多线程存在的意义四、线程的创建方式多线程的特性。

一、进程

1、定义

/**
进程：是一个正在执行中的程序。
	每一个进程执行都有一个执行顺序；该顺序是一个执行路径，或者叫一个控制单元。
*/

二、线程

1、定义

/**
    线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。通俗说就是进程是发生的一件事情，而线程就是控制着或者掌控这件事情的发生，一个线程中至少有一个线程。
*/

三、多线程

1、定义

/**
    Java VM  启动的时候会有一个进程java.exe.
    该进程中至少一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之为主线程。
    扩展：
    其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。
*/

2、如何创建多线程

/**
    多线程的出现能让程序产生同时运行效果。可以提高程序执行效率。
    例如：在java.exe进程执行主线程时，如果程序代码特别多，在堆内存中产生了很多对象，而同时对象调用完后，就成了垃圾。    如果垃圾过多就有可能是堆内存出现内存不足的现象，只是如果只有一个线程工作的话，程序的执行将会很低效；而如果有另一个线程帮助处理的话，如垃圾回收机制线程来帮助回收垃圾的话，程序的运行将变得更有效率。
*/

3、创建方式

（1）继承Thread类

/**
第一步：子类覆盖父类中的run方法，将线程运行的代码存放在run中。
第二步：建立子类对象的同时线程也被创建，通过调用start方法开启线程。
*/

    示例：

<span style="font-size:14px;">class Demo extends Thread//创建第一种方式，继承Thread类。
{
	public void run()//覆盖Thread类run()方法。
	{
		for(int x=0; x<60; x++)
			System.out.println("demo run----"+x);
	}
}
class ThreadDemo //主函数
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();//创建好了一个线程。
		d.start();//开启线程并执行该线程的run方法。
		//d.run();仅仅是对象调用方法。而线程创建了，并没有运行。
	}
}</span>

    练习题：创建2个或以上线程交替运行。

class Test extends Thread	//继承了Thread类。
{
	Test(String name)
	{
		super(name);	//引用父类构造函数。
	}
	public void run()	//覆盖Thread中run()方法。
	{
		for(int x=0; x<60; x++)
		{
			System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run..."+x);
		}
	}
}
class ThreadTest 
{
	public static void main(String[] args) 
	{
		Test t1 = new Test("one---");
		Test t2 = new Test("two+++");
		t1.start();//线程t1运行；
		t2.start();//线程t2运行；
		//t1和t2同时运行。
		for(int x=0; x<60; x++)//运行一个主线程
		{
			System.out.println("main....."+x);
		}
	}
}

（2）实现Runnable接口

/**
1、子类覆盖接口中的run方法。
2、通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数。
3、Thread类对象调用start方法开启线程。
*/
    示例： 
<pre name="code" class="java">class Ticket implements Runnable//实现Runnable接口。
{
	private  int tick = 100;
	public void run()//覆盖方法
	{
		while(true)
		{
			if(tick>0)
			{
				System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
			}
		}
	}
}
class  TicketDemo
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);//创建了一个线程；
		Thread t2 = new Thread(t);//创建了一个线程；
		Thread t3 = new Thread(t);//创建了一个线程；
		Thread t4 = new Thread(t);//创建了一个线程；
		t1.start();
		t2.start();
		t3.start();
		t4.start();
        }
}
 

     
 思考：为什么要给Thread类的构造函数传递Runnable的子类对象？ 

/**
    因为自定义的run方法所属的对象是Runnable接口的子类对象。
    所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
*/
 

（3）两种创建方式区别
 

 /**
   1.当某个类已经有父类了，这时无法用继续Thread方法建立线程，因为JAVA中无法多继承
   2.当某个类已经有父类了，这时可以实现Runnable方法建立线程，这样既继承了父类的属性又能建立线程。
   3.Runnable建立的多线程可以使用同一对象中封装的数据，而Thread要实现这样的功能必须将数据static化，但会导致数据的生命周期过长。
*/
 

4、线程的几种状态
     
如图： 

 

 

 
  

 

 

/**
 被创建：等待启动，调用start启动。
         运行状态：具有执行资格和执行权。
         临时状态（阻塞）：有执行资格，但是没有执行权。
         冻结状态：遇到sleep（time）方法和wait（）方法时，失去执行资格和执行权，sleep方法时间到或者调用notify（）方法时，获得执行资格，变为临时状态。
         消忙状态：stop（）方法，或者run方法结束。
注：当已经从创建状态到了运行状态，再次调用start（）方法时，就失去意义了，java运行时会提示线程状态异常。
*/
 
    图解： 

 
 

 

5、线程的安全问题
 

（1）多线程安全问题引出
 

/**
    当多个线程操作同一个共享数据时，一个线程对共享数据的多条代码只执行了一部分，还没执行完，而其他线程参与进来，导致共享数据错误。<pre name="code" class="java">    刚才示例中出现了，卖票程序卖到了-1、-2张票，这是怎么出来的呢？原因如下：
    当多条语句在操作同一线程共享数据时，一个线程对多条语句只执行了一部分，还未执行完，另一线程就参与进来执行了，导致共享数据发生错误。也就是说，由于cpu的快速切换，当执行线程一时，tic为1了，执行到if (tic > 0)的时候，cpu就可能将执行权给了线程二，那么线程一就停在这条语句了，tic还没减1，仍为1；线程二也判断if (tic > 0)是符合的，也停在这，以此类推。当cpu再次执行线程一的时候，打印的是1号，执行线程二的时候，是0号票，以此类推，就出现了错票的结果。其实就是多条语句被共享了，如果是一条语句，是不会出现此种情况的。
*/ 

 

    那么如何解决这个问题，如何呢？ok，不要着急，Java开发者们，考虑到了这种情况，于是提供了一种解决方案，且听我娓娓道来。
 

（2）解决问题
 

 
 
/**
    对于多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可参与执行，就不会出现问题了。Java对于多线程的安全问题，提供了专业的解决方式，即同步代码块，可操作共享数据。
a、同步代码块
        用法：
                  synchronized（对象）
                  {需要被同步的代码}<pre name="code" class="java">b、同步函数
    同步函数就是将修饰符synchronized放在返回类型的前面，下面通过同步函数给出多线程安全问题的具体解决方案：

1）目的：判断程序中是否有安全问题，若有，该如何解决。
2）解决：第一、明确哪些代码是多线程的运行代码
                  第二、明确共享数据
                  第三、明确多线程运行代码中，哪些语句是操作共享数据的。
*/ 
 
 
 
（3）示例
 
 
 
  
//1.同步代码块示例：
class Ticket implements Runnable
{
	private  int tick = 1000;
	Object obj = new Object();//任意对象
	public void run()
	{
		while(true)
		{
			synchronized(obj)//同步代码块，obj是一把锁
			{
				if(tick>0)
				{
					//try{Thread.sleep(10);}catch(Exception e){}//等待10秒钟
					System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
				}
			}
		}
	}
}

class  TicketDemo2
{
	public static void main(String[] args) 
	{

		Ticket t = new Ticket();

		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}<pre name="code" class="java">//2.同步函数示例：
class Ticket implements Runnable  
{  
    private int tick=100;  
    Object obj = new Object();  
    public void run()  
    {  
        while(true)  
        {  
            show();  
        }  
    }  
  //直接在函数上用synchronized修饰即可实现同步  
public synchronized void show()  
{  
        if(tick>0)  
        {  
        try  
        {     
            //使用线程中的sleep方法，模拟线程出现的安全问题  
            //因为sleep方法有异常声明，所以这里要对其进行处理  
            Thread.sleep(10);  
        }  
        catch (Exception e)  
        {  
        }  
        //显示线程名及余票数  
        System.out.println(Thread.currentThread().getName()+"..tick="+tick--);  
    }  
}     
}  
 
  
 
 
 
 
（4）小结
 
 
/**
   1. 同步代码块示例中：
 其中的对象如同锁，持有锁的线程可在同步中执行，没有锁的线程，即使获得cpu的执行权，也进不去，因为没有获取锁，是进不去代码块中执行共享数据语句的。
1）同步的前提：

a.必须有两个或两个以上的线程

b.必须保证同步的线程使用同一个锁，必须保证同步中只能有一个线程在运行。

    好处与弊端：解决了多线程的安全问题，多个线程需要判断锁，较为消耗资源。
   2. 同步函数
        格式：
                在函数上加上synchronized修饰符即可。
        那么同步函数用的是哪一个锁呢？
        函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。
*/
 
 
（5）静态函数的同步方式
 
 
/**
    如果同步函数被静态修饰后，经验证，使用的锁不是this了，因为静态方法中不可定义this，所以，这个锁不再是this了。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象：类名.class；该对象的类型是Class。
    所以静态的同步方法使用的锁是该方法所在类的字节码文件对象，即类名.class。
*/
    
  示例： 
 
 
 
/* 
加同步的单例设计模式————懒汉式 
*/  
class Single  
{  
    private static Single s = null;  
    private Single(){}  
    public static void getInstance()  
    {  
        if(s==null)  
        {  
            synchronized(Single.class)  
            {  
                if(s==null)  
                    s = new Single();  
            }  
        }  
        return s;  
    }  
}  
 
 
 
 
6、死锁
 
 
     当同步中嵌套同步时，就有可能出现死锁现象。
 
 
     示例：
 
 
/*
死锁。
同步中嵌套同步。

*/
class Ticket implements Runnable
{
	private  int tick = 1000;
	Object obj = new Object();
	boolean flag = true;
	public  void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(obj)
				{
					show();
				}
			}
		}
		else
			while(true)
				show();
	}
	public synchronized void show()//this
	{
		synchronized(obj)
		{
			if(tick>0)
			{
				try{Thread.sleep(10);}catch(Exception e){}
				System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
			}
		}
	}
}
class  DeadLockDemo
{
	public static void main(String[] args) 
	{

		Ticket t = new Ticket();

		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try{Thread.sleep(10);}catch(Exception e){}
		t.flag = false;
		t2.start();
	}
}

  
    原因分析 
 
 
 
/**
    分析死锁的原因：当t1、t2两个线程同时运行时，t1执行到代码到lockb时，t2抢夺了CPU的执行权，t1执行过程暂停，而t2在执行到locka时又被t1抢夺了执行权，但当t1执行到lockb时因为锁在t2手里没有释放，t1无法继续执行，同理t2，这样造成了程序死锁。
*/
 
 
7、线程间通信
 
 
（1）线程间通信初步解决
 
 
<span style="font-size:14px;">/**</span>
    多线程间的通信：将不同功能的代码封装在不同的线程代码中操作共同的资源。
    实现的思想：
        1.两线程实现Runnable接口，必须传入同一个对象
        2.建立一资源类，设置成员变量，就是线程中的共享数据
        3.在实现Runnable的子类中，将资源类名设置为成员变量，设置构造函数传入的参数为资源类型的变量，复写run()方法,操作资源数据。
*/
    
  示例1： 

 

 
 
<span style="font-size:12px;">class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
			//  t1    t2
	public synchronized void set(String name)
	{
		while(flag)
			try{this.wait();}catch(Exception e){}//t1(放弃资格)  t2(获取资格)
		this.name = name+"--"+count++;

		System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
		flag = true;
		this.notifyAll();
	}
	//  t3   t4  
	public synchronized void out()
	{
		while(!flag)
			try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
		System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
		flag = false;
		this.notifyAll();
	}
}

class Producer implements Runnable
{
	private Resource res;

	Producer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			res.set("+商品+");
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;

	Consumer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			res.out();
		}
	}
}
class ResourceDemo2   
{  
    public static void main(String[] args)   
    {  
        Resource r = new Resource();//表示操作的是同一个资源  
  
        new Thread(new Input(r)).start();//开启存线程  
  
        new Thread(new Output(r)).start();//开启取线程  
    }  
}  
/**
     解决方式： Wari()——notifyall(),判断条件为while
判断条件为while后，每次都要判断后才能wait,而notifyall可以将等待的输出线程全部唤醒。
分析示例发现了几个小问题：
        1）wait(),notify(),notifyAll(),用来操作线程为什么定义在了Object类中？
                a，这些方法存在与同步中。
                b，使用这些方法时必须要标识所属的同步的锁。同一个锁上wait的线程，只可以被同一个锁上的notify唤醒。
                c，锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。
        2）wait(),sleep()有什么区别？
              wait():释放cpu执行权，释放锁。
              sleep():释放cpu执行权，不释放锁。
        3）为甚么要定义notifyAll？
        因为在需要唤醒对方线程时。如果只用notify，容易出现只唤醒本方线程的情况。导致程序中的所以线程都等待。
*/</span>
 
 
（2）JDK1.5中提供了多线程升级解决方案
 
 
    将同步synchronized替换成显示的Lock操作。将Object中wait，notify，notifyAll，替换成了Condition对象。该Condition对象可以通过Lock锁进行获取，并支持多个相关的Condition对象。
 
 
 
    示例2：
 
 
/* 
线程间通信：  等待唤醒机制：升级版 ；生产者消费者  多个 
 
*/  
import java.util.concurrent.locks.*;  
  
class ProducerConsumerDemo{  
    public static void main(String[] args){  
        Resouse r = new Resouse();  
        Producer p = new Producer(r);  
        Consumer c = new Consumer(r);  
        Thread t1 = new Thread(p);  
        Thread t2 = new Thread(c);  
        Thread t3 = new Thread(p);  
        Thread t4 = new Thread(c);  
        t1.start();  
        t2.start();  
        t3.start();  
        t4.start();  
    }  
}  
  
class Resouse{  
    private String name;  
    private int count = 1;  
    private boolean flag =  false;   
    private Lock lock = new ReentrantLock();  
    private Condition condition_P = lock.newCondition();  
    private Condition condition_C = lock.newCondition();  
//要唤醒全部，否则都可能处于冻结状态，那么程序就会停止。这和死锁有区别的。  
    public void set(String name)throws InterruptedException{  
        lock.lock();  
        try{  
            while(flag)//循环判断，防止都冻结状态  
                condition_P.await();  
            this.name = name + "--" + count++;  
            System.out.println(Thread.currentThread().getName() + "..生成者--" + this.name);  
            flag = true;  
            condition_C.signal();  
        }finally{  
            lock.unlock();//释放锁的机制一定要执行  
        }         
    }  
    public void out()throws InterruptedException{  
        lock.lock();  
        try{  
            while(!flag)//循环判断，防止都冻结状态  
                condition_C.await();  
            System.out.println(Thread.currentThread().getName() + "..消费者." + this.name);  
            flag = false;  
            condition_P.signal();//唤醒全部  
        }finally{  
            lock.unlock();  
        }  
    }  
}  
  
class Producer implements Runnable{  
    private Resouse r;  
    Producer(Resouse r){  
        this.r = r;  
    }  
    public void run(){  
        while(true){  
            try{  
                r.set("--商品--");  
            }catch (InterruptedException e){}  
        }  
    }  
}  
  
class Consumer implements Runnable{  
    private Resouse r;  
    Consumer(Resouse r){  
        this.r = r;  
    }  
    public void run(){  
        while(true){  
            try{  
                r.out();  
            }catch (InterruptedException e){}  
        }  
    }  
}  <pre name="code" class="java">/**
示例说明：
1）、为何定义while判断标记：
原因是让被唤醒的线程再判断一次。
避免未经判断，线程不知是否应该执行，就执行本方的上一个已经执行的语句。如果用if，消费者在等着，两个生成着一起判断完flag后，cpu切换到其中一个如t1，另一个t3在wait，当t1唤醒冻结中的一个，是t3（因为它先被冻结的，就会先被唤醒），所以t3未经判断，又生产了一个。而没消费。

2）这里使用的是signal方法，而不是signalAll方法。是因为通过Condition的两个对象，分别唤醒对方，这就体现了Lock锁机制的灵活性。可以通过Contidition对象调用Lock接口中的方法，就可以保证多线程间通信的流畅性了。
*/
 
 
 
 
8、Thread中的其它方法
 
 
/**
1、停止线程：
    在java 1.5之后，就不再使用stop方法停止线程了。那么该如何停止线程呢？只有一种方法，就是让run方法结束。
    开启多线程运行，运行代码通常为循环结构，只要控制住循环，就可以让run方法结束，也就可以使线程结束。
  注：
    特殊情况：当线程处于冻结状态，就不会读取标记，那么线程就不会结束。如下：
*/
class StopThread implements Runnable{  
    private boolean flag = true;  
    public synchronized void run(){  
        while (flag){  
            try{  
                wait();  
            }catch (InterruptedException e) {  
                System.out.println(Thread.currentThread().getName() + "----Exception");  
                flag = false;  
            }  
            System.out.println(Thread.currentThread().getName() + "----run");  
        }  
    }  
    public void changeFlag(){  
        flag = false;  
    }  
}  
  
class  StopThreadDemo{  
    public static void main(String[] args) {  
        StopThread st = new StopThread();  
  
        Thread t1 = new Thread(st);  
        Thread t2 = new Thread(st);  
          
        t1.start();  
        t2.start();  
  
        int n = 0;  
        while (true){  
            if (n++ == 60){  
                st.changeFlag();  
                break;  
            }  
            System.out.println("Hello World!");  
        }  
    }  
}
   /**
     这时，当没有指定的方式让冻结的线程回复打破运行状态时，就需要对冻结进行清除。强制让线程回复到运行状态来，这样就可以操作标记让线程结束。
    在Thread类中提供了此种方法：interrupt()。此方法是为了让线程中断，但是并没有结束运行，让线程恢复到运行状态，再判断标记从而停止循环，run方法结束，线程结束。
*/
class StopThread implements Runnable{  
    private boolean flag = true;  
    public synchronized void run(){  
        while (flag){  
            try{  
                wait();  
            }catch (InterruptedException e){  
                System.out.println(Thread.currentThread().getName() + "----Exception");  
                flag = false;  
            }  
            System.out.println(Thread.currentThread().getName() + "----run");  
        }  
    }  
}  
  
class  StopThreadDemo{  
    public static void main(String[] args){  
        StopThread st = new StopThread();  
        Thread t1 = new Thread(st);  
        Thread t2 = new Thread(st);       
        t1.start();  
        t2.start();  
        int n = 0;  
        while (true){  
            if (n++ == 60){  
                t1.interrupt();  
                t2.interrupt();  
                break;  
            }  
            System.out.println("Hello World!");  
        }  
    }  
}  
/**
2、守护线程：---setDaemon()
    可将一个线程标记为守护线程，直接调用这个方法。此方法需要在启动前调用守护线程在这个线程结束后，会自动结束，则Jvm虚拟机也结束运行。 
  守护线程（后台线程），在启动前调用。后台线程自动结束。
*/  
    t1.setDaemon(true);  
    t2.setDaemon(true);  
    t1.start();  
    t2.start();  

/**
    3、临时加入线程：--join()
特点：当A线程执行到B线程方法时，A线程就会等待，B线程都执行完，A才会执行。join可用来临时加入线程执行。
*/
class Demo implements Runnable{  
    public void run(){  
        for(int x=0;x<90;x++){  
            System.out.println(Thread.currentThread().getName() + "----run" + x);  
        }  
    }  
}  
  
class  JoinDemo{  
    public static void main(String[] args)throws Exception{  
        Demo d = new Demo();  
        Thread t1 = new Thread(d);  
        Thread t2 = new Thread(d);  
        t1.start();       
        t2.start();  
        t1.join();//等t1执行完了，主线程才从冻结状态恢复，和t2抢执行权。t2执不执行完都无所谓。  
        int n = 0;  
        for(int x=0;x<80;x++){  
            System.out.println(Thread.currentThread().getName() + "----main" + x);  
        }  
        System.out.println("Over");  
    }  
}  
/**
4、优先级：setPriority()：
    在Thread中，存在着1~10这十个执行级别，最高的是 MAX_PRIORITY 为10，最低是 MIN_PRIORITY 为1，默认优先级是 NORM_PRIORITY 为5；但是并不是优先级越高，就会一直执行这个线程，只是说会优先执行到这个线程，此后还是有其他线程会和此线程抢夺cpu执行权的。
    优先级是可以设定的，可通过setPriority()设定，如：setPriority(Thread.MAX_PRIORITY)设优先级为最大。
    yield()：
    此方法可暂停当前线程，而执行其他线程。通过这个方法，可稍微减少线程执行频率，达到线程都有机会平均被执行的效果。如下：
*/
class Demo implements Runnable{  
    public void run(){  
        for(int x=0;x<90;x++){  
            System.out.println(Thread.currentThread().toString() + "----run" + x);  
            Thread.yield();//稍微减少线程执行频率。可达到线程都有机会达到平均运行的效果  
        }  
    }  
}  
  
class  YieldDemo{  
    public static void main(String[] args)throws Exception{  
        Demo d = new Demo();  
        Thread t1 = new Thread(d);  
        Thread t2 = new Thread(d);  
        t1.start();  
        t1.setPriority(Thread.MAX_PRIORITY);//设置线程优先级最大       
        t2.start();  
        System.out.println("Over");  
    }  
}
    
 这篇就到这里吧，下篇咱们再见。 
 
 
 
 
 
 
 
 
  -------  
  android培训 
  、 
  java培训 
  、期待与您交流！ --------- 
 
 
 
 
 
 
 
 


                

        

        

    




    

      

        

            

              
                
                  WL8721
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
java web项目中 获取resource路径下的文件路径

				
			

			

				

					weixin_33924220的博客
				

				

					05-29
					
					1万+
					
				

			

		

		

			
				
java web项目中 获取resource路径下的文件路径



public GetResource{
　　String path = GetResource.class.getClassLoader().getResource("xx/xx.txt").getPath();
}

----------扩展
一 相对路径的获得　　 说明:相对路径(即不写明时候到底相对谁)...

			
		

	



                

              
                



	

		

			

				
					
多线程

				
			

			

				

					cencen666的博客
				

				

					05-07
					
					72
					
				

			

		

		

			
				
第九周总结
4.28


文章目录一、 多线程1.程序，进程，线程2.单核与多核CPU，并行与并发3.创建多线程4.测试Thread的常用方法线程的调度

一、 多线程
1.程序，进程，线程



每个线程独自拥有虚拟机栈和程序计数器
方法区和堆由多个线程共同使用 即一个进程 一个

2.单核与多核CPU，并行与并发


何时使用多线程？
1.程序需要同时执行两个或多个任务
2.程序需要实现一些需要等待的任务
3.需要一些后台运行的程序

3.创建多线程
（1）方式一：继承于Thread类
1.创建一个继承

			
		

	



                


  
              

                


	

		

			

				
					
java获取访问路径方法

				
			

			

				

					hubo3085632的博客
				

				

					03-19
					
					2774
					
				

			

		

		

			
				
1 getContextPath()：获得项目名例如: /test2 getServletPath：获得servlet的访问路径例如: /helloworld3 getRequestURI：获得请求的绝对路径例如: /test/helloworld4 getRequestURL：获得请求的完整路径例如: http://localhost:8080/test/helloworld...

			
		

	





	

		

			

				
					
java web获取resource路径

				
			

			

				

					weixin_34391445的博客
				

				

					05-15
					
					1163
					
				

			

		

		

			
				
为什么80%的码农都做不了架构师？>>> 
                                        
                ...

			
		

	



		

			
		



	

		

			

				
					
Java中的HTML

				
			

			

				

					wyq1614406553的博客
				

				

					06-17
					
					6367
					
				

			

		

		

			
				
Java中的HTML
Html：超文本标记语言，它是与平台无关的，任何平台只需安装了浏览器都可以运行，不区分大小写。
Html的常用标签：
1.网页的头信息：可以设置网页标题，可以通知浏览器使用指定的码表解释html页面

标题标题：h1（一级标题），h2（二级标题），…h6(六级标题)
段落标签：用
换行标签：
字体加粗：   斜体：
大于号：&gt 小于号：&lt
空格：&am...

			
		

	





	

		

			

				
					
黑马程序员：轻松精通Java学习路线基础篇!.docx

					
最新发布

				
			

			

				

					11-20
				

			

		

		

			
				
 - 线程是程序执行的最小单位，Java 支持多线程编程，通过 Thread 类或 Runnable 接口实现。  - 线程同步：synchronized 关键字，wait(), notify(), notifyAll() 方法等，避免多线程竞态条件。  13. 集合框架  - ...

			
		

	





	

		

			

				
					
黑马程序员_毕向东最新经典Java基础视频

				
			

			

				

					03-30
				

			

		

		

			
				
根据提供的文件信息，我们可以推断出这是一套由知名IT教育机构“黑马程序员”出品、由讲师毕向东主讲的Java基础教学视频。由于实际视频内容无法直接获取，本篇将依据标题、描述以及部分标签内容，综合分析并展开相关...

			
		

	





	

		

			

				
					
自-黑马程序员：轻松精通Java学习路线基础篇 .docx

				
			

			

				

					10-25
				

			

		

		

			
				
10. **多线程**：了解并发编程的基础，学习如何创建和控制线程，理解线程同步和通信。  11. **数据库操作**：掌握SQL语言，学习JDBC（Java Database Connectivity）API，实现数据库的连接、查询、更新等操作。  12. ...

			
		

	





	

		

			

				
					
Java基础最全笔记文档

				
			

			

				

					07-29
				

			

		

		

			
				
除此之外，还有日期时间处理、正则表达式、异常处理、IO流、多线程、网络编程、反射、注解、动态代理、XML解析、工厂模式和装饰模式等进阶主题。  总的来说，Java的学习是一个系统的过程，从基础知识到高级特性的...

			
		

	





	

		

			

				
					
Java面试宝典2018年5月最新版

				
			

			

				

					08-21
				

			

		

		

			
				
《Java面试宝典2018年5月最新版》是一部专门为Java开发者准备的面试指导书籍，由黑马程序员团队精心编纂，旨在帮助求职者掌握Java面试中的核心知识点，提高面试成功率。书中涵盖了2018年最热门、最重要的Java技术...

			
		

	





	

		

			

				
					
java 文件路径

				
			

			

				

					草原孤狼的专栏
				

				

					06-21
					
					1810
					
				

			

		

		

			
				
Java路径
　　Java中使用的路径，分为两种：绝对路径和相对路径。具体而言，又分为四种：
　　一、URI形式的绝对资源路径


　　如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/aaa.b


　　URL是URI的特例。URL的前缀/协议，必须是Java熟悉的。URL可以打开资源，而URI则不行。
　　URL和URI对象可

			
		

	





	

		

			

				
					
Java读取resource文件/路径的几种方式

				
			

			

				

					oschina_40188932的博客
				

				

					12-18
					
					14万+
					
				

			

		

		

			
				
之前遇到过在项目打成jar包后文件读取不到文路径方式问题，整理了几个获取读取文件路径的方法希望大家能得到帮助
。

			
		

	





	

		

			

				
					
Java Resource路径小结

				
			

			

				

					semey的博客
				

				

					08-23
					
					1万+
					
				

			

		

		

			
				
文章摘抄至 http://blog.csdn.net/cutesource/article/details/6141768

 

首先一点很重要，Java中不存在标准的相对路径，各种相对路径取资源的方式都是基于某种规则转化为绝对路径。

然后一点也很重要，绝对不要直接使用绝对路径，否则死得很难看。

基于以上两点，总结Resource路径问题无非归结为一点：找基点，也就是在某种环

			
		

	





	

		

			

				
					
Java 资源文件路径详解（getResource）

				
			

			

				

					java梦工厂
				

				

					10-31
					
					2万+
					
				

			

		

		

			
				
获取资源文件的方法说明： 
       getResourceAsStream ()返回的是inputstream 
       getResource()返回:URL 
       Class.getResource(“”)    返回的是当前Class这个类所在包开始的为置 
       Class.getResource(“/”) 返回的是classpath的位置 
       ge

			
		

	





	

		

			

				
					
jsonp解决同源问题和java结合使用

				
			

			

				

					轻风木竹
				

				

					08-23
					
					481
					
				

			

		

		

			
				
1.概念 

浏览器的“同源策略(SOP:Same Origin Policy)”。浏览器限制脚本程序只能和同协议、同域名、同端口的脚本进行交互，这包括共享和传递变量等。这就造成一些涉及到多个服务器的应用在整合时一些麻烦。跨域访问的问题造成A站点的Ajax代码无法访问B站点的数据。

     如何解决跨域访问呢？那就要借助浏览器的一个特性：尽管浏览器不允许页面中的脚本程序跨域读取数据，但

			
		

	





	

		

			

				
					
java获取resource下的文件路径

				
			

			

				

					Captain249的博客
				

				

					08-02
					
					3万+
					
				

			

		

		

			
				
String path = xxx.class.getClassLoader().getResource("targetFile.txt").getPath();

#java获取文件目录
├── pom.xml
├── src
│  ├── main
│  │  ├── java
│  │  │  ├── com
│  │  │  │  ├── alipay
│  │ ...

			
		

	





	

		

			

				
					
java获取当前路径的几种方法

					
热门推荐

				
			

			

				

					snannan_268的专栏
				

				

					04-21
					
					16万+
					
				

			

		

		

			
				
java获取当前路径的几种方法1、利用System.getProperty()函数获取当前路径： System.out.println(System.getProperty("user.dir"));//user.dir指定了当前的路径 2、使用File提供的函数获取当前路径： File directory = new File("");//设定为当前文件夹 try{     System.o

			
		

	





	

		

			

				
					
Java工程师成神之路：基础篇

				
			

			

				

					
				

			

		

		

			
				
《Java工程师成神之路（基础篇）》是由阿里云开发者社区和Hollis合作推出的一套系统性的Java学习指南，该系列书籍旨在帮助Java工程师逐步提升技能，从入门到精通。该基础篇是整个系列的起点，它涵盖了Java编程的基础...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值