Java线程和Java修饰词

META标签

用来描述一个HTML网页文档的属性。

含义:元素可提供相关页面的元信息。

<meta> 元素可提供有关页面的元信息(meta-information),比如针对搜索引擎和更新频度的描述和关键词。

<meta> 标签位于文档的头部,不包含任何内容。<meta> 标签的属性定义了与文档相关联的名称/值对。

meta是html语言head区的一个辅助性标签。几乎所有的网页里,我们可以看到类似下面这段的html代码:

<head>

<meta http-equiv="content-Type" content="text/html; charset=gb2312" />

</head>

1.属性:

name属性主要用于描述网页,与之对应的属性值为content,content中的内容主要是便于 搜索引擎机器人查找信息和分类信息用的。

meta标签的name属性语法格式是:参数"content="具体的参数值">;。

其中name属性主要有以下几种参数:

A、Keywords(关键字)

说明:keywords用来告诉搜索引擎你网页的关键字是什么。

举例:

B、description(网站内容描述)

说明:description用来告诉搜索引擎你的网站主要内容。

网站内容描述(description)的设计要点:

①网页描述为自然语言而不是罗列关键词(与keywords设计正好相反);

②尽可能准确地描述网页的核心内容,通常为网页内容的摘要信息,也就是希望搜索引擎在检索结果中展示的摘要信息;

③网页描述中含有有效关键词;

④网页描述内容与网页标题内容有高度相关性;

⑤网页描述内容与网页主体内容有高度相关性;

⑥网页描述的文字不必太多,一般不超过搜索引擎检索结果摘要信息的最多字数(通常在100中文字之内,不同搜索引擎略有差异)。

举例:<meta name="description" content="This page is about the meaning of science,education,culture.">

C、robots(机器人向导)

说明:robots用来告诉搜索机器人哪些页面需要索引,哪些页面不需要索引。

content的参数有all,none,index,noindex,follow,nofollow。默认是all。

举例:<meta name="robots" content="none">

D、author(作者)

说明:标注网页的作者

 

http-equiv顾名思义,相当于http的文件头作用,它可以向浏览器传回一些有用的信息,以帮助正确和精确地显示网页内容,与之对应的属性值为content,content中的内容其实就是各个参数的变量值。

meta标签的http-equiv属性语法格式是: ;其中http-equiv属性主要有以下几种参数:

A、Expires(期限)

说明:可以用于设定网页的到期时间。一旦网页过期,必须到服务器上重新传输。

用法:<meta http-equiv="expires" content="Fri,12 Jan 2001 18:18:18 GMT">

注意:必须使用GMT的时间格式。

B、Pragma(cache模式)

说明:禁止浏览器从本地计算机的缓存中访问页面内容。

用法:<meta http-equiv="Pragma" content="no-cache">

注意:这样设定,访问者将无法脱机浏览。

C、Refresh(刷新)

说明:自动刷新并指向新页面。

用法:<meta http-equiv="Refresh" content="2;URL">;(注意后面的引号,分别在秒数的前面和网址的后面)

注意:其中的2是指停留2秒钟后自动刷新到URL网址。

D、Set-Cookie(cookie设定)

说明:如果网页过期,那么存盘的cookie将被删除。

用法:<meta http-equiv="Set-Cookie" content="cookievalue=xxx; expires=Friday,12-Jan-2001 18:18:18 GMT; path=/">

注意:必须使用GMT的时间格式。

E、Window-target(显示窗口的设定)

说明:强制页面在当前窗口以独立页面显示。

用法:<meta http-equiv="Window-target" content="_top">

注意:用来防止别人在框架里调用自己的页面。

F、content-Type(显示字符集的设定)

说明:设定页面使用的字符集。

用法:<meta http-equiv="content-Type" content="text/html; charset=gb2312">

G、content-Language(显示语言的设定)

用法:<meta http-equiv="Content-Language" content="zh-cn" />

2.功能:

meta标签的一个很重要的功能就是设置关键字,来帮助你的主页被各大搜索引擎登录,提高网站的访问量。

Java中的修饰词

  


            类内部     package内      子类       其他

public       允许        允许         允许       允许
protected    允许        允许         允许       不允许
default      允许        允许         不允许      不允许

private      允许        不允许        不允许      不允许

1、public

使用对象:类、接口、成员

介绍:无论它所处在的包定义在哪,该类(接口、成员)都是可访问的

2、protected

使用对象:成员

介绍:成员只能在定义它的包中被访问,如果在其他包中被访问,则实现这个方法的类

用protected修饰的成员(变量或方法),在类内部可以调用,同一个package下的其他类也可以调用,子类里也可以调用,其他地方则不可以调用,也就是说在其他

必须是该成员所属类的子类。

3、default 

无修饰词(默认),表示包访问权限(friendly, java语言中是没有friendly这个修饰符的,这样称呼应该是来源于c++ ),同一个包内可以访问,访问权限是包级访问权限;

4、private

使用对象:成员

介绍:成员只可以在定义它的类中被访问

5、abstract

使用对象:类、接口、方法

介绍:类中包括没有实现的方法,不能被实例化。如果是一个abstract方法,则方法体

为空,该方法的实现在子类中被定义,并且包含一个abstract方法的类必须是一个abstract类

6、final

使用对象:类、方法、字段、变量

介绍:被定义成final的类不允许出现子类,不能被覆盖(不应用于动态查询),字段值

不允许被修改。

7、static

使用对象:类、方法、字段、初始化函数

介绍:成名为static的内部类是一个顶级类,它和包含类的成员是不相关的。静态方法是类方法,是被指向到所属的类而不是类的实例。

静态字段是类字段,无论该字段所在的类创建了多少实例,该字段只存在一个实例被指向到所属的类而不是类的实例。初始化函数是在

装载类时执行的,而不是在创建实例时执行的。

9、synchronized

使用对象:方法

介绍:对于一个静态的方法,在执行之前jvm把它所在的类锁定;对于一个非静态类的方法,执行前把某个特定对象实例锁定。

10、volatile

使用对象:字段

介绍:因为异步线程可以访问字段,所以有些优化操作是一定不能作用在字段上的。

volatile有时可以代替synchronized。

11、transient

使用对象:字段

介绍:字段不是对象持久状态的一部分,不应该把字段和对象一起串起。

12、strictfp

使用对象:类、方法

介绍:strictfp修饰的类中所有的方法都隐藏了strictfp修饰词,方法执行的所有浮点

计算遵守:IEEE 754标准,所有取值包括中间的结果都必须表示为float或double类型,而不能利用

由本地平台浮点格式或硬件提供的额外精度或表示范围。

 

进程和线程

  

在并发性程序中,有两个基本的执行单元:进程和线程。

一个进程就是一个独立的执行环境。进程有着完整的,私有的基本的运行时资源,尤其是每个进程都有自己的内存空间。

进程通常会被看作是程序或者是应用程序的同义词。然而,用户看到的应用程序实际上可能是多个相互协作的进程。为了方便进程间通讯,绝大多数的操作系统都支持IPC(Inter Process Communication , 进程间通讯),诸如管道(pipe)和套接字(socket)。 IPC不仅可用于统一系统中进程间的相互通讯,还可以用于不同系统间的进程通讯。

大多数的java虚拟机的实现都是作为一个单独的进程的。通过使用ProcessBuilder,Java应用程序可以创建额外的进程。多进程的应用程序超出了本节讨论的范围。

线程有时被称为是轻型的进程。进程和线程都提供了一种运行环境。但是创建一个新的线程比创建一个新的进程需要更少的资源。

线程存在于进程之中——每个进程中至少有一个线程。同一进程的多个线程间共享进程的资源,包括内存和文件。这样做是出于效率的考虑,但是可能带来潜在的通信问题。

多线程是Java平台的一个重要特性。如果我们将进行诸如内存管理和信号处理的线程算上的“系统”线程计算上的话,那么每一个应用程序至少都有一个线程,

或者是多个线程。但是从应用程序的编程人员的角度来看,我们总是从一个叫做主线程的线程开始。该线程能够创建其他的线程,这点我们会在下一节中进行讨论。

线程对象

每一个线程都是和类Thread的实例相关联的。在Java中,有两种基本的使用Thread对象的方式,可用来创建并发性程序。

在应用程序需要发起异步任务的时候,只要生成一个Thread对象即可,这样可以直接控制线程的创建并对其进行管理。

把应用程序的任务交给执行器(executor),这样可以将对线程的管理从程序中抽离出来。

第一种方式   继承Thread 类  第二种方式   实现Runnable 接口

main方法也是由一个线程执行,这个线程叫主线程;  main{   m1{};   m2();   m3();  }

使用Runnable接口实现线程的好处  1.解除线程与线程功能的耦合     2.保留类的继承特性 

public class ThreadDemo {
        public static void main(String[] args) {
             // 父类的引用指向子类的对象
            Thread t=new MyThread();
            Thread t1=new MyThread1();
             //启动 线程
            t.start();
            t1.start();
        }
}
      //继承Thread类创建线程
class MyThread extends Thread{
      //线程要做的内容
     public void run() {
       for(int i=0;i<100;i++){         System.out.println("你是谁?"+i);       }    }}class MyThread1 extends Thread{     //线程要做的内容    public void run() {      for(int i=0;i<100;i++){         System.out.println("查水表?"+i);       }    }}

  

public class ThreadDemo2 {
    public static void main(String[] args) {
        Runnable r1=new MyRunnable1();
        Runnable r2=new MyRunnable2();
        Thread t1=new Thread(r1);
        Thread t2=new Thread(r2);
        t1.start();
        t2.start();
    }
}
class MyRunnable1 implements Runnable{
    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println("你是谁啊?");
        }
    }
}
class MyRunnable2 implements Runnable{
    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println("开门查水表?");
        }
    }
}

 

public class ThreadDemo3 {
  public static void main(String[] args) {
     ExecutorService es=Executors.newFixedThreadPool(3);
     Runnable r1=new Runnable(){
       public void run() {
          System.out.println("hello!");
       }
      };
     Runnable r2=new Runnable(){
       public void run() {
         System.out.println("helloWorld!");
       }
     };
     Runnable r3=new Runnable(){
      public void run() {          System.out.println("helloKitty!");
      }
     };
     es.submit(r1);
     es.submit(r2);
     es.submit(r3);
  }
}

频繁的从系统开辟新的线程会比较消耗系统资源,对程序的性能造成影响,我们可以设计出一个线程池,线程run完之后,而是会回到线程池中, 

使用jdk5提供的类创建线程池对象    ExecutorService es=Executors.newFixedThreadPool(个数);

原文地址:https://www.cnblogs.com/lxy151/p/8366562.html

时间: 2024-10-09 10:42:47

Java线程和Java修饰词的相关文章

java 线程栈 &amp; java.lang.StackOverflowError

网上搜索了一下,关于java的线程栈: JDK5.0以后每个线程堆栈大小为1M,以前每个线程堆栈大小为256K. JVM的内存,被划分了很多的区域: (来源:http://www.iteye.com/topic/808550) 1.程序计数器 每一个Java线程都有一个程序计数器来用于保存程序执行到当前方法的哪一个指令. 2.线程栈 线程的每个方法被执行的时候,都会同时创建一个帧(Frame)用于存储本地变量表.操作栈.动态链接.方法出入口等信息.每一个方法的调用至完成,就意味着一个帧在VM栈中

(转)【Java线程】Java内存模型总结

Java的并发采用的是共享内存模型(而非消息传递模型),线程之间共享程序的公共状态,线程之间通过写-读内存中的公共状态来隐式进行通信.多个线程之间是不能直接传递数据交互的,它们之间的交互只能通过共享变量来实现 同步是显式进行的.程序员必须显式指定某个方法或某段代码需要在线程之间互斥执行. 1.多线程通信 1.1 内存模型 Java线程之间的通信由Java内存模型(JMM)控制,JMM决定一个线程对共享变量的写入何时对另一个线程可见. 从抽象的角度来看,JMM定义了线程和主内存之间的抽象关系:线程

【Java线程】Java线程池ExecutorService

示例 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; public class Ch09_Executor { private static void run(ExecutorService threadPool) { for(int i = 1; i < 5; i++)

Java 线程--继承java.lang.Thread类实现线程

现实生活中的很多事情是同时进行的,Java中为了模拟这种状态,引入了线程机制.先来看线程的基本概念. 线程是指进程中的一个执行场景,也就是执行流程,进程和线程的区别: 1.每个进程是一个应用程序,都有独立的内存空间. 2.同一个进程中的线程共享其进程中的内存和资源. (共享的内存是堆内存和方法区内存,栈内存不共享,每个线程有自己的栈内存) 我们还需要了解以下基本内容: 1.什么是进程? 一个进程对应一个应用程序.例如:在Windows操作系统启动word就表示启动了一个进程.在Java开发环境下

【JAVA】从java线程来看java内存模型

前言 本来是想写两个线程,线程1输出1-98的奇数,线程2输出1-98的偶数,交替执行,在测试的时候发现线程安全问题,之后又引入到java内存模型,下面是几个demo. 1.版本1 //to print 1 ,3, 5...by thread1, print 2,4,6,8,10... by thread2 by turns public class Circle { public static boolean flag = true; public static void main(Strin

java线程池

1.new Thread的弊端 执行一个异步任务你还只是如下new Thread吗? 1 new Thread(new Runnable() { 2 3 @Override 4 public void run() { 5 // TODO Auto-generated method stub 6 } 7 }).start(); 那你就out太多了,new Thread的弊端如下: a. 每次new Thread新建对象性能差. b. 线程缺乏统一管理,可能无限制新建线程,相互之间竞争,及可能占用过

Java线程池与java.util.concurrent

Java(Android)线程池 介绍new Thread的弊端及Java四种线程池的使用,对Android同样适用.本文是基础篇,后面会分享下线程池一些高级功能. 1.new Thread的弊端执行一个异步任务你还只是如下new Thread吗? new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub } }).start(); 那你就out太多了,new Thre

java线程的简单实现及方法

java线程: 线程是一个程序内部的顺序控制流. cpu实际上在一个时间点上,只执行一个.只不过我们把cpu分成了多个时间片,由于速度很快,我们看起来像是多个线程.. 就像你的时间分成几片,这样 整体看来做事情有规律,效率就会高,何况是cpu呢. 线程的创建和启动: 方法一: java线程通过java.lang.Thread类来实现. VM启动时会有一个主方法所定义的线程, 每一个线程是Tread对象通过它的run()方法来完成操作. 启动线程方式:Thread的start()方法. 如下代码:

JAVA线程池的使用

概述 new Thread的弊端如下: a. 每次new Thread新建对象性能差. b. 线程缺乏统一管理,可能无限制新建线程,相互之间竞争,及可能占用过多系统资源导致死机或oom. c. 缺乏更多功能,如定时执行.定期执行.线程中断. 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间.那么有没有一种办法使得线程可以复用,就是执行完一个任务,并不被销毁,而是可以继续执行其他的任务?在Java中可