导航:首页 > 编程语言 > java防杀进程的原理是什么

java防杀进程的原理是什么

发布时间:2021-03-04 03:24:34

A. Android防止杀进程

1.在service中重写下面的方法,这个方法有三个返回值, START_STICKY是service被kill掉后自动重写创建 [代码]java代码: @Override public int onStartCommand(Intent intent, int flags, int startId) { return START_STICKY; }---------------- @Override public int onStartCommand(Intent intent, int flags, int startId) { // TODO Auto-generated method stub Log.v("TrafficService","startCommand"); flags = START_STICKY; return super.onStartCommand(intent, flags, startId); // return START_REDELIVER_INTENT; } 2.在Service的onDestroy()中重启Service. public void onDestroy() { Intent localIntent = new Intent(); localIntent.setClass(this, MyService.class); //销毁时重新启动Service this.startService(localIntent); } 用qq管家杀掉进程的时候,调用的是系统自带的强制kill功能(即settings里的),在kill时,会将应用的整个进程停掉,当然包括service在内,如果在running里将service强制kill掉,显示进程还在。不管是kill整个进程还是只kill掉进应用的 service,都不会重新启动service。不知道你是怎么实现重启的,实在是不解。 在eclipse中,用stop按钮kill掉进程的时候,倒是会重启service KILL问题: 1. settings 中stop service onDestroy方法中,调用startService进行Service的重启。 2.settings中force stop 应用 捕捉系统进行广播(action为android.intent.action.PACKAGE_RESTARTED) 3. 借助第三方应用kill掉running task 提升service的优先级 service开机启动 今天我们主要来探讨android怎么让一个service开机自动启动功能的实现。Android手机在启动的过程中会触发一个Standard Broadcast Action,名字叫android.intent.action.BOOT_COMPLETED(记得只会触发一次呀),在这里我们可以通过构建一个广播接收者来接收这个这个action.下面我就来简单写以下实现的步骤: 第一步:首先创建一个广播接收者,重构其抽象方法 onReceive(Context context, Intent intent),在其中启动你想要启动的Service或app。 [代码]java代码: import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.util.Log; public class BootBroadcastReceiver extends BroadcastReceiver { //重写onReceive方法 @Override public void onReceive(Context context, Intent intent) { //后边的XXX.class就是要启动的服务 Intent service = new Intent(context,XXXclass); context.startService(service); Log.v("TAG", "开机自动服务自动启动....."); //启动应用,参数为需要自动启动的应用的包名 Intent intent = getPackageManager().getLaunchIntentForPackage(packageName); context.startActivity(intent ); } } 第二步:配置xml文件,在re ceiver接收这种添加intent-filter配置 [代码]java代码: <receiver android:name="BootBroadcastReceiver"> <intent-filter> <action android:name="android.intent.action.BOOT_COMPLETED"></action> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </receiver> 第三步:添加权限 <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> 如何实现一个不会被杀死的进程 看Android的文档知道,当进程长期不活动,或系统需要资源时,会自动清理门户,杀死一些Service,和不可见的Activity等所在的进程。 但是如果某个进程不想被杀死(如数据缓存进程,或状态监控进程,或远程服务进程),应该怎么做,才能使进程不被杀死。 add android:persistent="true" into the <application> section in your AndroidManifest.xml 切记,这个 不可滥用,系统中用这个的service,app一多,整个系统就完蛋了。 目前系统中有phone等非常有限的,必须一直活着的应用在试用。 提升service优先级的方法 Android 系统对于内存管理有自己的一套方法,为了保障系统有序稳定的运信,系统内部会自动分配,控制程序的内存使用。当系统觉得当前的资源非常有限的时候,为了保 证一些优先级高的程序能运行,就会杀掉一些他认为不重要的程序或者服务来释放内存。这样就能保证真正对用户有用的程序仍然再运行。如果你的 Service 碰上了这种情况,多半会先被杀掉。但如果你增加 Service 的优先级就能让他多留一会,我们可以用 setForeground(true) 来设置 Service 的优先级。 为什么是 foreground ? 默认启动的 Service 是被标记为 background,当前运行的 Activity 一般被标记为 foreground,也就是说你给 Service 设置了 foreground 那么他就和正在运行的 Activity 类似优先级得到了一定的提高。当让这并不能保证你得 Service 永远不被杀掉,只是提高了他的优先级。 从Android 1.5开始,一个已启动的service可以调用startForeground(int, Notification)将service置为foreground状态,调用stopForeground(boolean)将service置为 background状态。 我们会在调用startForeground(int, Notification)传入参数notification,它会在状态栏里显示正在进行的foreground service。background service不会在状态栏里显示。 在Android 1.0中,将一个service置为foreground状态: setForeground(true); mNM.notify(id, notification); 将一个service置为background状态: mNM.cancel(id); setForeground(false); 对比看出,在1.0 API中调用setForeground(boolean)只是简单的改变service的状态,用户不会有任何觉察。新API中强制将 notification和改变service状态的动作绑定起来,foreground service会在状态栏显示,而background service不会。 Remote service controller & binding 跨进程调用Service。暂时不研究。 如何防止Android应用中的Service被系统回收? 很多朋友都在问,如何防止Android应用中的Service被系统回收?下面简单解答一下。 对于Service被系统回收,一般做法是通过提高优先级可以解决,在AndroidManifest.xml文件中对于intent-filter可以通过 android:priority = "1000"这个属性设置最高优先级,1000是最高值,如果数字越小则优先级越低,同时实用于广播,推荐大家如果你的应用很重要,可以考虑通过系统常用intent action来触发。

B. Java如何杀死Windows系统下的进程

在java中有调用外部程序的类,Runtime.getRuntime().exec("./**.exe");此函数返回的是一个Process 对象,该对象在创建后,可以回对它进行 destroy () 杀掉子进程、 waitFor () 导致当前答线程等待,如有必要,一直要等到由该 Process 对象表示的进程已经终止。 而你想要的屏蔽空格的问题,在批处理中可以把整个命令用双引号包起来就可以避免了。

C. java反射机制的实现原理

反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。下面具体介绍一下java的反射机制。这里你将颠覆原来对java的理解。
Java的反射机制的实现要借助于4个类:class,Constructor,Field,Method;其中class代表的时类对 象,Constructor-类的构造器对象,Field-类的属性对象,Method-类的方法对象。通过这四个对象我们可以粗略的看到一个类的各个组 成部分。

Class:程序运行时,java运行时系统会对所有的对象进行运行时类型的处理。这项信息记录了每个对象所属的类,虚拟机通常使用运行时类型信息选择正 确的方法来执行(摘自:白皮书)。但是这些信息我们怎么得到啊,就要借助于class类对象了啊。在Object类中定义了getClass()方法。我 们可以通过这个方法获得指定对象的类对象。然后我们通过分析这个对象就可以得到我们要的信息了。

比如:ArrayList arrayList;

Class clazz = arrayList.getClass();

然后我来处理这个对象clazz。

当然了Class类具有很多的方法,这里重点将和Constructor,Field,Method类有关系的方法。

Reflection 是 Java 程序开发语言的特征之一,它允许运行中的 Java 程序对自身进行检查,或者说“自审”,并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多,但是个人认为要想对java有个更加深入的了解还是应该掌握的。

1.检测类:

reflection的工作机制

考虑下面这个简单的例子,让我们看看 reflection 是如何工作的。

import java.lang.reflect.*;

public class DumpMethods {

public static void main(String args[]) {

try {

Class c = Class.forName(args[0]);

Method m[] = c.getDeclaredMethods();

for (int i = 0; i < m.length; i++)

System.out.println(m[i].toString());

} catch (Throwable e) {

System.err.println(e);

}

}

}

按如下语句执行:

java DumpMethods java.util.ArrayList

这个程序使用 Class.forName 载入指定的类,然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

Java类反射中的主要方法

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用,以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用:

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数,

Constructor[] getConstructors() -- 获得类的所有公共构造函数

Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)

Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用,在参数类型数组中使用了字段名:

Field getField(String name) -- 获得命名的公共字段

Field[] getFields() -- 获得类的所有公共字段

Field getDeclaredField(String name) -- 获得类声明的命名的字段

Field[] getDeclaredFields() -- 获得类声明的所有字段

用于获得方法信息函数:

Method getMethod(String name, Class[] params) -- 使用特定的参数类型,获得命名的公共方法

Method[] getMethods() -- 获得类的所有公共方法

Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型,获得类声明的命名的方法

Method[] getDeclaredMethods() -- 获得类声明的所有方法

使用 Reflection:

用于 reflection 的类,如 Method,可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤:第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中,用 java.lang.Class 类来描述类和接口等。

下面就是获得一个 Class 对象的方法之一:

Class c = Class.forName("java.lang.String");

这条语句得到一个 String 类的类对象。还有另一种方法,如下面的语句:

Class c = int.class;

或者

Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Intege ) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法,以取得该类中定义的所有方法的列表。

一旦取得这个信息,就可以进行第三步了——使用 reflection API 来操作这些信息,如下面这段代码:

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

处理对象:

a.创建一个Class对象

b.通过getField 创建一个Field对象

c.调用Field.getXXX(Object)方法(XXX是Int,Float等,如果是对象就省略;Object是指实例).

例如:

import java.lang.reflect.*;

import java.awt.*;

class SampleGet {

public static void main(String[] args) {

Rectangle r = new Rectangle(100, 325);

printHeight(r);

}

static void printHeight(Rectangle r) {

Field heightField;

Integer heightValue;

Class c = r.getClass();

try {

heightField = c.getField("height");

heightValue = (Integer) heightField.get(r);

System.out.println("Height: " + heightValue.toString());

} catch (NoSuchFieldException e) {

System.out.println(e);

} catch (SecurityException e) {

System.out.println(e);

} catch (IllegalAccessException e) {

System.out.println(e);

}

}

}

安全性和反射:

在处理反射时安全性是一个较复杂的问题。反射经常由框架型代码使用,由于这一点,我们可能希望框架能够全面接入代码,无需考虑常规的接入限制。但是,在其它情况下,不受控制的接入会带来严重的安全性风险,例如当代码在不值得信任的代码共享的环境中运行时。

由于这些互相矛盾的需求,Java编程语言定义一种多级别方法来处理反射的安全性。基本模式是对反射实施与应用于源代码接入相同的限制:

从任意位置到类公共组件的接入

类自身外部无任何到私有组件的接入

受保护和打包(缺省接入)组件的有限接入

不过至少有些时候,围绕这些限制还有一种简单的方法。我们可以在我们所写的类中,扩展一个普通的基本类 java.lang.reflect.AccessibleObject 类。这个类定义了一种setAccessible方法,使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。唯一的问题在于如果使用了安全性管理 器,它将检测正在关闭接入检测的代码是否许可了这样做。如果未许可,安全性管理器抛出一个例外。

下面是一段程序,在TwoString 类的一个实例上使用反射来显示安全性正在运行:

public class ReflectSecurity {

public static void main(String[] args) {

try {

TwoString ts = new TwoString("a", "b");

Field field = clas.getDeclaredField("m_s1");

// field.setAccessible(true);

System.out.println("Retrieved value is " +

field.get(inst));

} catch (Exception ex) {

ex.printStackTrace(System.out);

}

}

}

如果我们编译这一程序时,不使用任何特定参数直接从命令行运行,它将在field .get(inst)调用中抛出一个IllegalAccessException异常。如果我们不注释 field.setAccessible(true)代码行,那么重新编译并重新运行该代码,它将编译成功。最后,如果我们在命令行添加了JVM参数 -Djava.security.manager以实现安全性管理器,它仍然将不能通过编译,除非我们定义了ReflectSecurity类的许可权 限。

反射性能:(转录别人的啊)

反射是一种强大的工具,但也存在一些不足。一个主要的缺点是对性能有影响。使用反射基本上是一种解释操作,我们可以告诉JVM,我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

下面的程序是字段接入性能测试的一个例子,包括基本的测试方法。每种方法测试字段接入的一种形式 -- accessSame 与同一对象的成员字段协作,accessOther 使用可直接接入的另一对象的字段,accessReflection 使用可通过反射接入的另一对象的字段。在每种情况下,方法执行相同的计算 -- 循环中简单的加/乘顺序。

程序如下:

public int accessSame(int loops) {

m_value = 0;

for (int index = 0; index < loops; index++) {

m_value = (m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return m_value;

}

public int acces

sReference(int loops) {

TimingClass timing = new TimingClass();

for (int index = 0; index < loops; index++) {

timing.m_value = (timing.m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return timing.m_value;

}

public int accessReflection(int loops) throws Exception {

TimingClass timing = new TimingClass();

try {

Field field = TimingClass.class.

getDeclaredField("m_value");

for (int index = 0; index < loops; index++) {

int value = (field.getInt(timing) +

ADDITIVE_VALUE) * MULTIPLIER_VALUE;

field.setInt(timing, value);

}

return timing.m_value;

} catch (Exception ex) {

System.out.println("Error using reflection");

throw ex;

}

}

在上面的例子中,测试程序重复调用每种方法,使用一个大循环数,从而平均多次调用的时间衡量结果。平均值中不包括每种方法第一次调用的时间,因此初始化时间不是结果中的一个因素。下面的图清楚的向我们展示了每种方法字段接入的时间:

图 1:字段接入时间 :

我们可以看出:在前两副图中(Sun JVM),使用反射的执行时间超过使用直接接入的1000倍以上。通过比较,IBM JVM可能稍好一些,但反射方法仍旧需要比其它方法长700倍以上的时间。任何JVM上其它两种方法之间时间方面无任何显著差异,但IBM JVM几乎比Sun JVM快一倍。最有可能的是这种差异反映了Sun Hot Spot JVM的专业优化,它在简单基准方面表现得很糟糕。反射性能是Sun开发1.4 JVM时关注的一个方面,它在反射方法调用结果中显示。在这类操作的性能方面,Sun 1.4.1 JVM显示了比1.3.1版本很大的改进。

如果为为创建使用反射的对象编写了类似的计时测试程序,我们会发现这种情况下的差异不象字段和方法调用情况下那么显著。使用newInstance()调 用创建一个简单的java.lang.Object实例耗用的时间大约是在Sun 1.3.1 JVM上使用new Object()的12倍,是在IBM 1.4.0 JVM的四倍,只是Sun 1.4.1 JVM上的两部。使用Array.newInstance(type, size)创建一个数组耗用的时间是任何测试的JVM上使用new type[size]的两倍,随着数组大小的增加,差异逐步缩小。随着jdk6.0的推出,反射机制的性能也有了很大的提升。期待中….

总结:

Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象(根据安全性限制),无需提前硬编码目标类。这些特性使得反射 特别适用于创建以非常普通的方式与对象协作的库。例如,反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。Java reflection 非常有用,它使类和数据结构能按名称动态检索相关信息,并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大,并且是其它一些常用语言,如 C、C++、Fortran 或者 Pascal 等都不具备的。

但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相 对很少涉及的部分,缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性 能问题才变得至关重要。

许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑,反射等绕过了源代码的技术会带来维护问 题。反射代码比相应的直接代码更复杂,正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方 ——记录其在目标类中的使用。

一下是对应各个部分的例子:

具体的应用:

1、 模仿instanceof 运算符号

class A {}

public class instance1 {

public static void main(String args[])

{

try {

Class cls = Class.forName("A");

boolean b1

= cls.isInstance(new Integer(37));

System.out.println(b1);

boolean b2 = cls.isInstance(new A());

System.out.println(b2);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

2、 在类中寻找指定的方法,同时获取该方法的参数列表,例外和返回值

import java.lang.reflect.*;

public class method1 {

private int f1(

Object p, int x) throws NullPointerException

{

if (p == null)

throw new NullPointerException();

return x;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method1");

Method methlist[]

= cls.getDeclaredMethods();

for (int i = 0; i < methlist.length;

i++)

Method m = methlist[i];

System.out.println("name

= " + m.getName());

System.out.println("decl class = " +

m.getDeclaringClass());

Class pvec[] = m.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("

param #" + j + " " + pvec[j]);

Class evec[] = m.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println("exc #" + j

+ " " + evec[j]);

System.out.println("return type = " +

m.getReturnType());

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

3、 获取类的构造函数信息,基本上与获取方法的方式相同

import java.lang.reflect.*;

public class constructor1 {

public constructor1()

{

}

protected constructor1(int i, double d)

{

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor1");

Constructor ctorlist[]

= cls.getDeclaredConstructors();

for (int i = 0; i < ctorlist.length; i++) {

Constructor ct = ctorlist[i];

System.out.println("name

= " + ct.getName());

System.out.println("decl class = " +

ct.getDeclaringClass());

Class pvec[] = ct.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("param #"

+ j + " " + pvec[j]);

Class evec[] = ct.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println(

"exc #" + j + " " + evec[j]);

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

4、 获取类中的各个数据成员对象,包括名称。类型和访问修饰符号

import java.lang.reflect.*;

public class field1 {

private double d;

public static final int i = 37;

String s = "testing";

public static void main(String args[])

{

try {

Class cls = Class.forName("field1");

Field fieldlist[]

= cls.getDeclaredFields();

for (int i

= 0; i < fieldlist.length; i++) {

Field fld = fieldlist[i];

System.out.println("name

= " + fld.getName());

System.out.println("decl class = " +

fld.getDeclaringClass());

System.out.println("type

= " + fld.getType());

int mod = fld.getModifiers();

System.out.println("modifiers = " +

Modifier.toString(mod));

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

5、 通过使用方法的名字调用方法

import java.lang.reflect.*;

public class method2 {

public int add(int a, int b)

{

return a + b;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Method meth = cls.getMethod(

"add", partypes);

method2 methobj = new method2();

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj

= meth.invoke(methobj, arglist);

Integer retval = (Integer)retobj;

System.out.println(retval.intValue());

}

catch (Throwable e) {

System.err.println(e);

}

}

}

6、 创建新的对象

import java.lang.reflect.*;

public class constructor2 {

public constructor2()

{

}

public constructor2(int a, int b)

{

System.out.println(

"a = " + a + " b = " + b);

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Constructor ct

= cls.getConstructor(partypes);

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj = ct.newInstance(arglist);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

7、 变更类实例中的数据的值

import java.lang.reflect.*;

public class field2 {

public double d;

public static void main(String args[])

{

try {

Class cls = Class.forName("field2");

Field fld = cls.getField("d");

field2 f2obj = new field2();

System.out.println("d = " + f2obj.d);

fld.setDouble(f2obj, 12.34);

System.out.println("d = " + f2obj.d);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

使用反射创建可重用代码:

1、 对象工厂

Object factory(String p) {

Class c;

Object o=null;

try {

c = Class.forName(p);// get class def

o = c.newInstance(); // make a new one

} catch (Exception e) {

System.err.println("Can't make a " + p);

}

return o;

}

public class ObjectFoundry {

public static Object factory(String p)

throws ClassNotFoundException,

InstantiationException,

IllegalAccessException {

Class c = Class.forName(p);

Object o = c.newInstance();

return o;

}

}

2、 动态检测对象的身份,替代instanceof

public static boolean

isKindOf(Object obj, String type)

throws ClassNotFoundException {

// get the class def for obj and type

Class c = obj.getClass();

Class tClass = Class.forName(type);

while ( c!=null ) {

if ( c==tClass ) return true;

c = c.getSuperclass();

}

return false;

}

D. 求解,C++这样的防杀进程是怎么做到的

最简单的方式是:用system函数。如:system("taskkill /im exedbg32.exe /f" )

E. java中幽灵线程是什么,以及它的作用和工作原理是什么

你说的幽灵是之daemon 线程吧
当正在运行的线程都是daemon线程时,Java 虚拟机退出。
而对於普通线程运行时虚拟机是不会结束的。

F. Java中的反射机制的原理和用途是什么

JAVA反射(放射)机制:“程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言”。从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#
不是动态语言。但是JAVA有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完
全未知的classes。换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对
象实体、或对其fields设值、或唤起其methods。

用途:Java反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类;在运行时构造任意一个类的对象;在运行时判断任意一个类所具有的成员变量和方法;在运行时调用任意一个对象的方法;生成动态代理。

有时候我们说某个语言具有很强的动态性,有时候我们会区分动态和静态的不同技术与作法。我们朗朗上口动态绑定(dynamic binding)、动态链接(dynamic linking)、动态加载(dynamic loading)等。然而“动态”一词其实没有绝对而普遍适用的严格定义,有时候甚至像面向对象当初被导入编程领域一样,一人一把号,各吹各的调。

一般而言,开发者社群说到动态语言,大致认同的一个定义是:“程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言”。从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#不是动态语言。

尽管在这样的定义与分类下Java不是动态语言,它却有着一个非常突出的动态相关机制:Reflection。
这个字的意思是“反射、映象、倒影”,用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说,Java程
序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体、或对其fields设值、或唤起其
methods。这种“看透class”的能力(the ability of the program to examine
itself)被称为introspection(内省、内观、反省)。Reflection和introspection是常被并提的两个术语。

Java如何能够做出上述的动态特性呢?这是一个深远话题,本文对此只简单介绍一些概念。整个篇幅最主要还是介绍
Reflection
APIs,也就是让读者知道如何探索class的结构、如何对某个“运行时才获知名称的class”生成一份实体、为其fields设值、调用其
methods。本文将谈到java.lang.Class,以及java.lang.reflect中的Method、Field、Constructor等等classes。

G. 这个java程序所达到的功能的原理是什么

你自己选的数字根据他的算法算完以后都是9的倍数
你可以继续观察
他图上凡是9的倍数 图片都是一样的
所以就能“猜”出你选的图形。

任何10到99的数 减去 个位十位只和都为9的倍数

如果不明白的话 可以追问

H. 怎么尽量防止进程被杀

这样的:首先从Ring3获得你自己的句柄(不要用GetCurrentProcess,这个函数只能返回一个伪句柄版-1),从Ring3传进来,驱动保权存起来。在MyNtTerminateProcess中,你可以用PsGetCurrentProcess获得调用者的句柄,和传进来的句柄比较,如果相同,那么是自己结束自己,放行;如果不是,则代表是其他进程要杀死本进程,拦截!

I. 杀进程是什么意思,有啥用

Windows XP/2000的任务管理器是一个非常有用的工具,能让你看到系统中正在运行哪些程序(进程),只要你平时多看任务管理器中的进程列表,熟悉系统的基本进程,就可以随时发现可疑进程,这对防范木马和病毒大有裨益!不过有一些可疑进程,你用任务管理器却无法杀掉,这该怎么办呢?

一、哪些系统进程不能关掉

Windows运行的时候,会启动多个进程。只要你按下“Ctrl+Alt+Del”键打开任务管理器,点击“查看”/选择列,勾选“PIO(进程标识符)”,然后单击“进程”标签,即可看到这些进程。不过有一些进程个人用户根本用不到,例如Systray.exe(显示系统托盘小喇叭图标)、Ctfmon.exe(微软Office输入法)、Winampa.exe等,我们完全可以禁止它们,这样做并不会影响系统的正常运行。

二、如何关闭任务管理器杀不了的进程

如果你在任务管理器中无法关闭某个可疑进程,可以使用下面的方法强行关闭,注意不要杀掉进程表中的系统核心进程:

1. 使用Windows XP/2000自带的工具

从Windows 2000开始,Windows系统就自带了一个用户态调试工具Ntsd,它能够杀掉大部分进程,因为被调试器附着的进程会随调试器一起退出,所以只要你在命令行下使用Ntsd调出某进程,然后退出Ntsd即可终止该进程,而且使用Ntsd会自动获得Debug权限,因此Ntsd能杀掉大部分的进程。

操作方法:单击“开始”/程序/附件/命令提示符,输入命令:ntsd -c q -p PID(把最后那个PID,改成你要终止的进程的PID)。在进程列表中你可以查到某个进程的PID,例如我们要关闭图1中的Explorer.exe进程,输入:ntsd -c q -p 408即可。

以上参数-p表示后面跟随的是进程PID, -c q表示执行退出Ntsd的调试命令,从命令行把以上参数传递过去就行了。

2. 使用专门的软件来杀进程

任务管理器杀不掉的进程,你可以使用专门的软件关闭。有很多软件可以杀进程,例如进程杀手、IceSword、柳叶擦眼、系统查看大师、Kill process等。

(1)进程杀手2.5(【点击下载“进程杀手2.5”】)
http://software.pchome.net/system/monitor/18017.html

它能够浏览系统中正在运行的所有进程,包括用Ctrl+Alt+Del 看不到的进程,可以精简进程、自动中止系统基本进程以外的所有进程,对木马和病毒进程有一定清除作用,你可以用它随时中止任一个正在运行的进程,选中该进程,按“中止进程”按钮即可。

(2)IceSword(【点击下载“IceSword”】)
http://software.pchome.net/system/sysenhance/18523.html

如今系统级木马后门功能越来越强,一般都可轻易隐藏进程、端口、注册表、文件信息,普通进程工具根本无法发现这些“幕后黑手”。IceSword使用大量新颖的内核技术,可以查出所有隐藏进程。

要查看当前进程,请点击“进程”按钮,在右部列出的进程中,隐藏的进程会以红色醒目地标记出,以方便查找系统级后门。如果要结束某进程,可以先选中它(按住Ctrl键可选择多个进程),然后使用右键菜单的“结束进程”,即可关闭之。

(3)柳叶擦眼

它可以列出系统中所有的进程(包括隐藏的),并可以杀死进程,能自动标示出系统文件,自动中止基本进程外的所有进程,还具有IE保护功能。

运行软件后,单击“柳叶擦眼”可以显示当前正在运行的所有进程,你只需注意那些“定义级别”为“未知”及“危险”的进程,按“降妖伏魔”按钮关闭它们即可。

(4)系统查看大师1.0

目前许多木马都是在后台运行的,它们运行时会隐藏自己的窗口,因此你无法在屏幕上看到它们。该软件可以获取隐藏的不可见窗口,让你发现木马踪影、关闭之。

软件运行后,在左侧视图中点击“取不可见窗口”按钮,右侧的窗口中就会显示出所有当前运行的、隐藏的不可见窗口标题,选定其中的可疑窗口,然后点击右下端的“结束此窗口”按钮,即可关闭之。如果你要关闭某进程,可以单击“进程列表”按钮,选中该进程,然后右击鼠标在弹出的窗口中,单击“结束进程”即可。

J. java怎么杀掉java进程

java中有调用外部程序的类,Runtime.getRuntime().exec("./**.exe");此函数返回的是一个Process 对象,该对象在创建后,可以对它进行 destroy () 杀掉子进程、 waitFor () 导致当前线程等待,如有必要,一直要等到由该 Process 对象表示的进程已经终止。 如下例子可以杀掉已经打开的文本进程:


importjava.io.BufferedReader;
importjava.io.InputStreamReader;
publicclassTest
{
publicstaticvoidmain(String[]args)
{
try
{
String[]cmd=
{"notepad.exe"};
Processproc=Runtime.getRuntime().exec(cmd);//开启文本
BufferedReaderin=newBufferedReader(newInputStreamReader(proc
.getInputStream()));
Stringstring_Temp=in.readLine();
while(string_Temp!=null)
{
System.out.println(string_Temp);
if(string_Temp.indexOf("notepad.exe")!=-1)
Runtime.getRuntime().exec("Taskkill/IMnotepad.exe");
string_Temp=in.readLine();
}
}
catch(Exceptione)
{
//结束进程
}
}

结果如下:

阅读全文

与java防杀进程的原理是什么相关的资料

热点内容
穿越雪中悍刀行收女主的小说 浏览:54
奇怪的美发沙龙剧情介绍 浏览:969
《沐风之女》电影巴巴鱼 浏览:4
psd文件如何转换成cdr 浏览:907
英语课作弊2电影 浏览:584
光盘里文件格式 浏览:423
易天下 著; 浏览:530
struts2上传文件json 浏览:640
可以看那种片的网站 浏览:671
重生古惑仔千人晒马的小说 浏览:15
火影小说 浏览:897
小说女主叫苏沐男主叫陆修 浏览:148
如懿传小说完整版txt 浏览:267
word打印背景变多 浏览:646
win10安装密钥跳过 浏览:171
美国的网络制式 浏览:692
十部顶级古墓电影 浏览:208
如何理解数据越用越值钱 浏览:83
我的可爱女友糖糖免费阅读 浏览:971
前度2陈伟霆 浏览:555

友情链接