src/main/decaf/internal/util/concurrent/Threading.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _DECAF_INTERNAL_UTIL_CONCURRENT_THREADING_H_
#define _DECAF_INTERNAL_UTIL_CONCURRENT_THREADING_H_

#include <decaf/util/Config.h>

#include <decaf/lang/Thread.h>

namespace decaf {
namespace internal {
namespace util {
namespace concurrent {

    using decaf::lang::Thread;

    class ThreadLocalImpl;
    struct ThreadHandle;
    struct MonitorHandle;

    class DECAF_API Threading {
    private:

        Threading();
        Threading(const Threading&);
        Threading& operator= (const Threading&);

    public:

        static void initialize();

        static void shutdown();

        static void lockThreadsLib();

        static void unlockThreadsLib();

        static void dumpRunningThreads();

    public:  // Monitors

        static MonitorHandle* takeMonitor(bool alreadyLocked = false);

        static void returnMonitor(MonitorHandle* monitor, bool alreadyLocked = false);

        static void enterMonitor(MonitorHandle* monitor);

        static bool tryEnterMonitor(MonitorHandle* monitor);

        static void exitMonitor(MonitorHandle* monitor);

        static bool waitOnMonitor(MonitorHandle* monitor, long long mills, int nanos);

        static void notifyWaiter(MonitorHandle* monitor);

        static void notifyAllWaiters(MonitorHandle* monitor);

        static bool isMonitorLocked(MonitorHandle* monitor);

    public:  // Threads

        static ThreadHandle* createNewThread(Thread* parant, const char* name,
                                             long long stackSize);

        static void start(ThreadHandle* thread);

        static bool join(ThreadHandle* thread, long long mills, int nanos);

        static void interrupt(ThreadHandle* thread);
        static bool interrupted();
        static bool isInterrupted(ThreadHandle* thread, bool reset);

        static void yeild();
        static bool sleep(long long mills, int nanos);

        static long long getThreadId(ThreadHandle* thread);

        static int getThreadPriority(ThreadHandle* thread);

        static void setThreadPriority(ThreadHandle* thread, int priority);

        static const char* getThreadName(ThreadHandle* thread);

        static void setThreadName(ThreadHandle* thread, const char* name);

        static Thread::State getThreadState(ThreadHandle* thread);

        static bool isThreadAlive(ThreadHandle* thread);

        static void destroyThread(ThreadHandle* thread);

        static ThreadHandle* createThreadWrapper(decaf::lang::Thread* parent, const char* name);

        static Thread* getCurrentThread();

        static ThreadHandle* getCurrentThreadHandle();

        static void park(Thread* thread);

        static bool park(Thread* thread, long long mills, int nanos);

        static void unpark(Thread* thread);

    public:  // Thread local storage

        static int createThreadLocalSlot(ThreadLocalImpl* threadLocal);

        static void* getThreadLocalValue(int slot);

        static void setThreadLocalValue(int slot, void* value);

        static void destoryThreadLocalSlot(int slot);

    private:

        static ThreadHandle* attachToCurrentThread();

        static void monitorEnterUsingThreadId(MonitorHandle* monitor, ThreadHandle* thread);
        static bool monitorTryEnterUsingThreadId(MonitorHandle* monitor, ThreadHandle* thread);
        static void monitorExitUsingThreadId(MonitorHandle* monitor, ThreadHandle* thread);
    };

}}}}

#endif /* _DECAF_INTERNAL_UTIL_CONCURRENT_THREADING_H_ */

---