Package Name: java.lang.thread

Return to: Package List

with java.lang; use java.lang;
with java.lang.Throwable; use java.lang.Throwable;
with java.lang.String; use java.lang.String;
with java.lang.Runnable; use java.lang.Runnable;
-- with java.lang.ThreadGroup; use java.lang.ThreadGroup; -- circular

package java.lang.Thread is
    type Thread_Obj is new Object with record
        Runnable : aliased Runnable_Obj;  -- implements Runnable
    end record;

    type Thread_Ptr is access all Thread_Obj'Class;
    MIN_PRIORITY : constant Integer;

    pragma Import(Java, MIN_PRIORITY);
    NORM_PRIORITY : constant Integer;

    pragma Import(Java, NORM_PRIORITY);
    MAX_PRIORITY : constant Integer;

    pragma Import(Java, MAX_PRIORITY);

    function currentThread return Thread_Ptr;

    procedure yield;
    procedure sleep(

        millis : Long_Integer);
    procedure sleep(
        millis : Long_Integer;

        nanos : Integer);
    procedure init_Thread(Obj : access Thread_Obj'Class);

    function new_Thread(Obj : Thread_Ptr := null) return Thread_Ptr;
    function new_Thread(
        target : Runnable_Ptr;
	Obj : Thread_Ptr := null)

      return Thread_Ptr;
    function new_Thread(
        name : String_Ptr;
	Obj : Thread_Ptr := null)

      return Thread_Ptr;
    function new_Thread(
        target : Runnable_Ptr;
        name : String_Ptr;
	Obj : Thread_Ptr := null)

      return Thread_Ptr;

    procedure start(Obj : access Thread_Obj);

    procedure run(Obj : access Thread_Obj);

    procedure stop(Obj : access Thread_Obj);
    procedure stop(Obj : access Thread_Obj;

        o : Throwable_Ptr);

    procedure interrupt(Obj : access Thread_Obj);

    function interrupted return Boolean;

    function isInterrupted(Obj : access Thread_Obj) return Boolean;

    procedure destroy(Obj : access Thread_Obj);

    function isAlive(Obj : access Thread_Obj) return Boolean;

    procedure suspend(Obj : access Thread_Obj);

    procedure resume(Obj : access Thread_Obj);
    procedure setPriority(Obj : access Thread_Obj;

        newPriority : Integer);

    function getPriority(Obj : access Thread_Obj) return Integer;
    procedure setName(Obj : access Thread_Obj;

        name : String_Ptr);

    function getName(Obj : access Thread_Obj) return String_Ptr;

    function activeCount return Integer;

    type Thread_Array is array(Positive range <>) of Thread_Ptr;
    function enumerate(
        tarray : Thread_Array)

      return Integer;

    function countStackFrames(Obj : access Thread_Obj) return Integer;
    procedure join(Obj : access Thread_Obj;

        millis : Long_Integer);
    procedure join(Obj : access Thread_Obj;
        millis : Long_Integer;

        P2 : Integer);

    procedure join(Obj : access Thread_Obj);

    procedure dumpStack;
    procedure setDaemon(Obj : access Thread_Obj;

        on : Boolean);

    function isDaemon(Obj : access Thread_Obj) return Boolean;

    procedure checkAccess(Obj : access Thread_Obj);

    function toString(Obj : access Thread_Obj) return String_Ptr;
    pragma Import(Java, setDaemon);
    pragma Import(Java, yield);
    pragma Import(Java, setName);
    pragma Import(Java, destroy);
    pragma Import(Java, start);
    pragma Import(Java, isDaemon);
    pragma Import(Java, getName);
    pragma Import(Java, suspend);
    pragma Import(Java, run);
    pragma Import(Java, sleep);
    pragma Import(Java, enumerate);
    pragma Import(Java, setPriority);
    pragma Import(Java, checkAccess);
    pragma Import(Java, dumpStack);
    pragma Import(Java, join);
    pragma Import(Java, currentThread);
    pragma Import(Java, isAlive);
    pragma Import(Java, interrupt);
    pragma Import(Java, getPriority);
    pragma Import(Java, stop);
    pragma Import(Java, interrupted);
    pragma Import(Java, isInterrupted);
    pragma Import(Java, resume);
    pragma Import(Java, toString);
    pragma Import(Java, countStackFrames);

    pragma Import(Java, activeCount);
    pragma Import(Java_Constructor, init_Thread);

    pragma Import(Java_Constructor, new_Thread);
end java.lang.Thread;